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

package/dist/index.mjs

@@ -180,10 +180,13 @@ function extractQuotedIdentifier(original, start) {
     return null;
   }
   let pos = start + 1;
-  while (pos < original.length && original[pos] !== '"') {
-    if (original[pos] === '"' && original[pos + 1] === '"') {
-      pos += 2;
-      continue;
+  while (pos < original.length) {
+    if (original[pos] === '"') {
+      if (original[pos + 1] === '"') {
+        pos += 2;
+        continue;
+      }
+      break;
     }
     pos++;
   }
@@ -251,6 +254,39 @@ function parseTableRef(original, scrubbed, 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;
   }
@@ -290,7 +326,8 @@ function parseTableRef(original, scrubbed, start) {
       aliasPos++;
     }
   }
-  if (original[aliasPos] === '"' && !afterTable.startsWith("on ") && !afterTable.startsWith("left ") && !afterTable.startsWith("right ") && !afterTable.startsWith("inner ") && !afterTable.startsWith("full ") && !afterTable.startsWith("cross ") && !afterTable.startsWith("join ") && !afterTable.startsWith("where ") && !afterTable.startsWith("group ") && !afterTable.startsWith("order ") && !afterTable.startsWith("limit ") && !afterTable.startsWith("as ")) {
+  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;
@@ -302,10 +339,11 @@ function parseTableRef(original, scrubbed, start) {
     position: nameStart
   };
 }
-function findJoinClauses(original, scrubbed, sources) {
+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) {
@@ -377,22 +415,182 @@ function findJoinClauses(original, scrubbed, sources) {
   }
   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);
+  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 offset = 0;
+  let totalOffset = 0;
   for (const join of joinClauses) {
     const scrubbedOnClause = scrubbed.slice(join.onStart, join.onEnd);
     const originalOnClause = query.slice(join.onStart, join.onEnd);
@@ -407,7 +605,14 @@ function qualifyJoinColumns(query) {
       if (scrubbedOnClause[lhsEnd] !== '"')
         continue;
       let lhsStartPos = lhsEnd - 1;
-      while (lhsStartPos >= 0 && scrubbedOnClause[lhsStartPos] !== '"') {
+      while (lhsStartPos >= 0) {
+        if (scrubbedOnClause[lhsStartPos] === '"') {
+          if (lhsStartPos > 0 && scrubbedOnClause[lhsStartPos - 1] === '"') {
+            lhsStartPos -= 2;
+            continue;
+          }
+          break;
+        }
         lhsStartPos--;
       }
       if (lhsStartPos < 0)
@@ -491,8 +696,79 @@ function qualifyJoinColumns(query) {
       }
     }
     if (clauseResult !== originalOnClause) {
-      result = result.slice(0, join.onStart + offset) + clauseResult + result.slice(join.onEnd + offset);
-      offset += clauseResult.length - originalOnClause.length;
+      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;
@@ -2062,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,12 +1,13 @@
 export declare function scrubForRewrite(query: string): string;
 export declare function adaptArrayOperators(query: string): string;
 /**
- * Qualifies unqualified column references in JOIN ON clauses.
+ * Qualifies unqualified column references in JOIN ON clauses, SELECT, WHERE,
+ * and ORDER BY clauses.
  *
  * Transforms patterns like:
- *   `left join "b" on "col" = "col"`
+ *   `select "col" from "a" left join "b" on "col" = "col" where "col" in (...)`
  * To:
- *   `left join "b" on "a"."col" = "b"."col"`
+ *   `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().

package/package.json

@@ -3,7 +3,7 @@
   "module": "./dist/index.mjs",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
-  "version": "1.1.3",
+  "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 {