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

package/dist/duckdb-introspect.mjs

@@ -188,10 +188,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++;
   }
@@ -259,6 +262,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;
   }
@@ -298,7 +334,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;
@@ -310,10 +347,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) {
@@ -385,22 +423,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);
@@ -415,7 +613,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)
@@ -499,8 +704,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;

package/dist/helpers.mjs

@@ -115,6 +115,13 @@ function buildStructLiteral(value, schema) {
   });
   return sql`struct_pack(${sql.join(parts, sql.raw(", "))})`;
 }
+function buildMapLiteral(value, valueType) {
+  const keys = Object.keys(value);
+  const vals = Object.values(value);
+  const keyList = buildListLiteral(keys, "TEXT");
+  const valList = buildListLiteral(vals, valueType?.endsWith("[]") ? valueType.slice(0, -2) : valueType);
+  return sql`map(${keyList}, ${valList})`;
+}
 var duckDbList = (name, elementType) => customType({
   dataType() {
     return `${elementType}[]`;
@@ -160,6 +167,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) {