lakeql 0.1.8 → 0.1.9

package/dist/bin.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-import { createParquetLake, readParquetMetadata, memoryStore, writePartitionedParquet, broadcastJoin, createOutputManifest, partitionedParquetOutputEntries, fingerprint, writeOutputManifest } from './chunk-MXGEAVHL.js';
-import { __commonJS, __toESM, LakeqlError, matches, evaluate, isTimestampValue } from './chunk-TFD5RFKB.js';
+import { createParquetLake, readParquetMetadata, memoryStore, writePartitionedParquet, broadcastJoin, partitionedParquetOutputEntries } from './chunk-6XXXYVXT.js';
+import { createOutputManifest, fingerprint, writeOutputManifest } from './chunk-ZVHJD6R3.js';
+import { __commonJS, __toESM, LakeqlError, matches, evaluate, intervalValue, isTimestampValue, isIntervalValue } from './chunk-4VJQ56HF.js';
 import { readFile, mkdir, writeFile } from 'fs/promises';
 import { dirname } from 'path';
 
@@ -2598,7 +2599,7 @@ var require_pgsql_ast_parser = __commonJS({
             return ret;
           }
           exports2.normalizeInterval = normalizeInterval;
-          function intervalToString(value2) {
+          function intervalToString2(value2) {
             var _a, _b, _c;
             value2 = normalizeInterval(value2);
             const ret = [];
@@ -2623,7 +2624,7 @@ var require_pgsql_ast_parser = __commonJS({
             }
             return ret.join(" ");
           }
-          exports2.intervalToString = intervalToString;
+          exports2.intervalToString = intervalToString2;
           function num(v) {
             v = Math.abs(v);
             return v < 10 ? "0" + v : v.toString();
@@ -7291,15 +7292,510 @@ var require_pgsql_ast_parser = __commonJS({
 
 // ../sql/dist/index.js
 var import_pgsql_ast_parser = __toESM(require_pgsql_ast_parser(), 1);
+
+// ../sql/dist/sql-scan.js
+function findTopLevelKeyword(sql, keyword, start) {
+  let depth = 0;
+  let quote;
+  for (let index = start; index < sql.length; index += 1) {
+    const char = sql[index];
+    const next = sql[index + 1];
+    if (quote !== void 0) {
+      if (char === quote) {
+        if (next === quote) {
+          index += 1;
+          continue;
+        }
+        quote = void 0;
+      }
+      continue;
+    }
+    if (char === "-" && next === "-") {
+      index = skipLineComment(sql, index + 2);
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      index = skipBlockComment(sql, index + 2);
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(")
+      depth += 1;
+    else if (char === ")")
+      depth = Math.max(0, depth - 1);
+    if (depth === 0 && keywordAt(sql, index, keyword))
+      return index;
+  }
+  return -1;
+}
+function keywordAt(sql, index, keyword) {
+  if (sql.slice(index, index + keyword.length).toLowerCase() !== keyword)
+    return false;
+  return isBoundary(sql[index - 1]) && isBoundary(sql[index + keyword.length]);
+}
+function isBoundary(char) {
+  return char === void 0 || !/[A-Za-z0-9_]/u.test(char);
+}
+function skipLineComment(sql, index) {
+  const newline = sql.indexOf("\n", index);
+  return newline === -1 ? sql.length : newline;
+}
+function skipBlockComment(sql, index) {
+  const end = sql.indexOf("*/", index);
+  return end === -1 ? sql.length : end + 1;
+}
+
+// ../sql/dist/qualify-prepass.js
+var CLAUSE_KEYWORDS = ["order by", "limit", "offset"];
+function extractTopLevelQualify(sql) {
+  const qualify = findTopLevelKeyword(sql, "qualify", 0);
+  if (qualify === -1)
+    return { sql };
+  const bodyStart = qualify + "qualify".length;
+  const bodyEnd = nextClauseStart(sql, bodyStart);
+  const predicate = sql.slice(bodyStart, bodyEnd).trim();
+  if (predicate.length === 0)
+    return { sql };
+  const rewritten = `${sql.slice(0, qualify)} ${sql.slice(bodyEnd)}`.trim();
+  return { sql: rewritten, qualify: predicate };
+}
+function nextClauseStart(sql, start) {
+  let best = sql.length;
+  for (const keyword of CLAUSE_KEYWORDS) {
+    const index = findTopLevelKeyword(sql, keyword, start);
+    if (index !== -1 && index < best)
+      best = index;
+  }
+  return best;
+}
+
+// ../sql/dist/window-prepass.js
+var FRAME_KEYWORDS = ["rows", "range", "groups"];
+function extractWindowFrames(sql) {
+  const named = inlineNamedWindows(sql);
+  let out = "";
+  const frames = [];
+  let index = 0;
+  while (index < named.length) {
+    const over = findKeyword(named, "over", index);
+    if (over === -1) {
+      out += named.slice(index);
+      break;
+    }
+    const beforeOver = stripWindowNullTreatment(named.slice(index, over));
+    out += beforeOver.sql;
+    const afterOver = skipWhitespace(named, over + "over".length);
+    if (named[afterOver] !== "(") {
+      out += named.slice(over, afterOver);
+      index = afterOver;
+      frames.push(beforeOver.ignoreNulls === void 0 ? void 0 : { ignoreNulls: beforeOver.ignoreNulls });
+      continue;
+    }
+    const close = matchingParen(named, afterOver);
+    if (close === -1) {
+      out += named.slice(over);
+      break;
+    }
+    const content = named.slice(afterOver + 1, close);
+    const stripped = stripFrame(content);
+    frames.push(stripped.frame === void 0 && beforeOver.ignoreNulls === void 0 ? void 0 : {
+      ...stripped.frame === void 0 ? {} : { text: stripped.frame },
+      ...beforeOver.ignoreNulls === void 0 ? {} : { ignoreNulls: beforeOver.ignoreNulls }
+    });
+    out += `${named.slice(over, afterOver + 1)}${stripped.content})`;
+    index = close + 1;
+  }
+  return { sql: out, frames };
+}
+function inlineNamedWindows(sql) {
+  const fromKeyword = findTopLevelKeyword(sql, "from", 0);
+  const windowKeyword = findTopLevelKeyword(sql, "window", fromKeyword === -1 ? 0 : fromKeyword);
+  if (windowKeyword === -1)
+    return rewriteNamedWindowRefs(sql, /* @__PURE__ */ new Map());
+  const definitionsStart = skipWhitespace(sql, windowKeyword + "window".length);
+  const definitionsEnd = findNamedWindowClauseEnd(sql, definitionsStart);
+  const definitions = parseNamedWindowDefinitions(sql.slice(definitionsStart, definitionsEnd));
+  const withoutClause = `${sql.slice(0, windowKeyword)} ${sql.slice(definitionsEnd)}`;
+  return rewriteNamedWindowRefs(withoutClause, resolveNamedWindows(definitions));
+}
+function parseNamedWindowDefinitions(sql) {
+  const definitions = /* @__PURE__ */ new Map();
+  let index = 0;
+  while (index < sql.length) {
+    index = skipWhitespace(sql, index);
+    if (index >= sql.length)
+      break;
+    const name = readIdentifier(sql, index);
+    if (name === void 0)
+      break;
+    index = skipWhitespace(sql, name.end);
+    if (!keywordAt(sql, index, "as"))
+      break;
+    index = skipWhitespace(sql, index + "as".length);
+    if (sql[index] !== "(")
+      break;
+    const close = matchingParen(sql, index);
+    if (close === -1)
+      break;
+    definitions.set(name.name, sql.slice(index + 1, close).trim());
+    index = skipWhitespace(sql, close + 1);
+    if (sql[index] !== ",")
+      break;
+    index += 1;
+  }
+  return definitions;
+}
+function resolveNamedWindows(definitions) {
+  const resolved = /* @__PURE__ */ new Map();
+  const resolve = (name, stack) => {
+    const cached = resolved.get(name);
+    if (cached !== void 0)
+      return cached;
+    const definition = definitions.get(name);
+    if (definition === void 0)
+      return void 0;
+    if (stack.has(name))
+      return definition;
+    const base = readIdentifier(definition, skipWhitespace(definition, 0));
+    if (base !== void 0) {
+      const parent = resolve(base.name, /* @__PURE__ */ new Set([...stack, name]));
+      if (parent !== void 0) {
+        const merged = `${parent} ${definition.slice(base.end).trim()}`.trim();
+        resolved.set(name, merged);
+        return merged;
+      }
+    }
+    resolved.set(name, definition);
+    return definition;
+  };
+  for (const name of definitions.keys())
+    resolve(name, /* @__PURE__ */ new Set());
+  return resolved;
+}
+function rewriteNamedWindowRefs(sql, definitions) {
+  if (definitions.size === 0)
+    return sql;
+  let out = "";
+  let index = 0;
+  while (index < sql.length) {
+    const over = findKeyword(sql, "over", index);
+    if (over === -1) {
+      out += sql.slice(index);
+      break;
+    }
+    out += sql.slice(index, over);
+    const afterOver = skipWhitespace(sql, over + "over".length);
+    if (sql[afterOver] === "(") {
+      const close = matchingParen(sql, afterOver);
+      if (close === -1) {
+        out += sql.slice(over);
+        break;
+      }
+      const content = sql.slice(afterOver + 1, close).trim();
+      const name2 = readIdentifier(content, 0);
+      if (name2 !== void 0 && definitions.has(name2.name)) {
+        const rest = content.slice(name2.end).trim();
+        out += `over (${definitions.get(name2.name)}${rest.length === 0 ? "" : ` ${rest}`})`;
+      } else {
+        out += sql.slice(over, close + 1);
+      }
+      index = close + 1;
+      continue;
+    }
+    const name = readIdentifier(sql, afterOver);
+    if (name !== void 0 && definitions.has(name.name)) {
+      out += `over (${definitions.get(name.name)})`;
+      index = name.end;
+      continue;
+    }
+    out += sql.slice(over, afterOver);
+    index = afterOver;
+  }
+  return out;
+}
+function stripWindowNullTreatment(sql) {
+  const suffix = /(\s+)(ignore|respect)\s+nulls\s*$/iu.exec(sql);
+  if (suffix !== null && suffix[2] !== void 0) {
+    return {
+      sql: sql.slice(0, suffix.index) + (suffix[1] ?? ""),
+      ignoreNulls: suffix[2].toLowerCase() === "ignore"
+    };
+  }
+  const close = previousNonWhitespace(sql, sql.length - 1);
+  if (close === -1 || sql[close] !== ")")
+    return { sql };
+  const open = matchingOpenParen(sql, close);
+  if (open === -1)
+    return { sql };
+  const content = sql.slice(open + 1, close);
+  const stripped = stripTopLevelNullTreatment(content);
+  if (stripped.ignoreNulls === void 0)
+    return { sql };
+  return {
+    sql: `${sql.slice(0, open + 1)}${stripped.sql}${sql.slice(close)}`,
+    ignoreNulls: stripped.ignoreNulls
+  };
+}
+function stripTopLevelNullTreatment(sql) {
+  let depth = 0;
+  let quote;
+  for (let index = 0; index < sql.length; index += 1) {
+    const char = sql[index];
+    const next = sql[index + 1];
+    if (quote !== void 0) {
+      if (char === quote) {
+        if (next === quote) {
+          index += 1;
+          continue;
+        }
+        quote = void 0;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(")
+      depth += 1;
+    else if (char === ")")
+      depth = Math.max(0, depth - 1);
+    if (depth !== 0)
+      continue;
+    const match = /^(ignore|respect)\s+nulls\b/iu.exec(sql.slice(index));
+    if (match === null || match[1] === void 0 || !isBoundary(sql[index - 1]))
+      continue;
+    const start = trimLeftWhitespace(sql, index);
+    const end = trimRightWhitespace(sql, index + match[0].length);
+    return {
+      sql: `${sql.slice(0, start)}${sql.slice(end)}`.replace(/\s+,/u, ","),
+      ignoreNulls: match[1].toLowerCase() === "ignore"
+    };
+  }
+  return { sql };
+}
+function stripFrame(content) {
+  const start = findFrameStart(content);
+  if (start === -1)
+    return { content };
+  const frame = content.slice(start).trim();
+  return { content: trimTrailingHorizontalWhitespace(content.slice(0, start)), frame };
+}
+function trimTrailingHorizontalWhitespace(value2) {
+  return value2.replace(/[ \t\f\v]+$/u, "");
+}
+function findFrameStart(content) {
+  let depth = 0;
+  let quote;
+  for (let index = 0; index < content.length; index += 1) {
+    const char = content[index];
+    const next = content[index + 1];
+    if (quote !== void 0) {
+      if (char === quote) {
+        if (next === quote) {
+          index += 1;
+          continue;
+        }
+        quote = void 0;
+      }
+      continue;
+    }
+    if (char === "-" && next === "-") {
+      index = skipLineComment(content, index + 2);
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      index = skipBlockComment(content, index + 2);
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(")
+      depth += 1;
+    else if (char === ")")
+      depth = Math.max(0, depth - 1);
+    if (depth === 0 && FRAME_KEYWORDS.some((keyword) => keywordAt(content, index, keyword))) {
+      return index;
+    }
+  }
+  return -1;
+}
+function findKeyword(sql, keyword, start) {
+  let quote;
+  for (let index = start; index < sql.length; index += 1) {
+    const char = sql[index];
+    const next = sql[index + 1];
+    if (quote !== void 0) {
+      if (char === quote) {
+        if (next === quote) {
+          index += 1;
+          continue;
+        }
+        quote = void 0;
+      }
+      continue;
+    }
+    if (char === "-" && next === "-") {
+      index = skipLineComment(sql, index + 2);
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      index = skipBlockComment(sql, index + 2);
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (keywordAt(sql, index, keyword))
+      return index;
+  }
+  return -1;
+}
+function findNamedWindowClauseEnd(sql, start) {
+  const candidates = ["order", "limit", "offset", "fetch", "union", "qualify"];
+  let end = sql.length;
+  for (const keyword of candidates) {
+    const index = findTopLevelKeyword(sql, keyword, start);
+    if (index !== -1 && index < end)
+      end = index;
+  }
+  return end;
+}
+function matchingParen(sql, open) {
+  let depth = 0;
+  let quote;
+  for (let index = open; index < sql.length; index += 1) {
+    const char = sql[index];
+    const next = sql[index + 1];
+    if (quote !== void 0) {
+      if (char === quote) {
+        if (next === quote) {
+          index += 1;
+          continue;
+        }
+        quote = void 0;
+      }
+      continue;
+    }
+    if (char === "-" && next === "-") {
+      index = skipLineComment(sql, index + 2);
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      index = skipBlockComment(sql, index + 2);
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(")
+      depth += 1;
+    else if (char === ")") {
+      depth -= 1;
+      if (depth === 0)
+        return index;
+    }
+  }
+  return -1;
+}
+function matchingOpenParen(sql, close) {
+  let depth = 0;
+  let quote;
+  for (let index = close; index >= 0; index -= 1) {
+    const char = sql[index];
+    const previous = sql[index - 1];
+    if (quote !== void 0) {
+      if (char === quote)
+        quote = void 0;
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      if (previous === char) {
+        index -= 1;
+        continue;
+      }
+      quote = char;
+      continue;
+    }
+    if (char === ")")
+      depth += 1;
+    else if (char === "(") {
+      depth -= 1;
+      if (depth === 0)
+        return index;
+    }
+  }
+  return -1;
+}
+function skipWhitespace(sql, index) {
+  let cursor = index;
+  while (/\s/u.test(sql[cursor] ?? ""))
+    cursor += 1;
+  return cursor;
+}
+function readIdentifier(sql, index) {
+  const char = sql[index];
+  if (char === '"') {
+    let cursor = index + 1;
+    let name = "";
+    while (cursor < sql.length) {
+      const current = sql[cursor];
+      if (current === '"' && sql[cursor + 1] === '"') {
+        name += '"';
+        cursor += 2;
+        continue;
+      }
+      if (current === '"')
+        return { name, end: cursor + 1 };
+      name += current ?? "";
+      cursor += 1;
+    }
+    return void 0;
+  }
+  const match = /^[A-Za-z_][A-Za-z0-9_]*/u.exec(sql.slice(index));
+  if (match === null)
+    return void 0;
+  return { name: match[0], end: index + match[0].length };
+}
+function previousNonWhitespace(sql, index) {
+  let cursor = index;
+  while (cursor >= 0 && /\s/u.test(sql[cursor] ?? ""))
+    cursor -= 1;
+  return cursor;
+}
+function trimLeftWhitespace(sql, index) {
+  let cursor = index;
+  while (cursor > 0 && /\s/u.test(sql[cursor - 1] ?? ""))
+    cursor -= 1;
+  return cursor;
+}
+function trimRightWhitespace(sql, index) {
+  let cursor = index;
+  while (cursor < sql.length && /\s/u.test(sql[cursor] ?? ""))
+    cursor += 1;
+  return cursor;
+}
+
+// ../sql/dist/index.js
 var MAX_SQL_LENGTH = 128e3;
 var MAX_AST_DEPTH = 128;
+var PROTOTYPE_MUTATION_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function parseSql(sql, options = {}) {
   if (sql.length > MAX_SQL_LENGTH) {
     throwParse(`SQL input length exceeds ${MAX_SQL_LENGTH}`);
   }
+  const windowPrepass = extractWindowFrames(sql);
+  const prepass = extractTopLevelQualify(windowPrepass.sql);
   let statements;
   try {
-    statements = (0, import_pgsql_ast_parser.parse)(sql);
+    statements = (0, import_pgsql_ast_parser.parse)(prepass.sql);
   } catch (error) {
     if (error instanceof Error)
       throwParse(error.message);
@@ -7310,11 +7806,14 @@ function parseSql(sql, options = {}) {
   const statement = asNode(statements[0], "statement");
   assertAstDepth(statement);
   const context = newSqlParseContext(options);
+  context.windowFrames = windowPrepass.frames;
+  if (prepass.qualify !== void 0)
+    context.qualifySql = prepass.qualify;
   if (statement.type === "with")
     return withStatementToAst(statement, context);
   if (statement.type !== "select")
     throwUnsupported("Only SELECT statements are supported");
-  return selectStatementToAst(statement, context);
+  return selectStatementToAst(statement, context, context.qualifySql);
 }
 function parseSqlStatement(sql, options = {}) {
   const describe = parseDescribeStatement(sql);
@@ -7353,7 +7852,7 @@ function withStatementToAst(statement, context) {
   const outer = asNode(statement.in, "CTE outer query");
   if (outer.type !== "select")
     throwUnsupported("Only SELECT after WITH is supported");
-  const ast = selectStatementToAst(outer, context);
+  const ast = selectStatementToAst(outer, context, context.qualifySql);
   ast.cte = { name, query: cteQuery };
   return ast;
 }
@@ -7362,7 +7861,26 @@ function validateCteQuery(ast) {
     throwUnsupported("Nested CTE joins and subqueries are not supported");
   }
 }
-function selectStatementToAst(statement, context = newSqlParseContext()) {
+function selectStatementToAst(statement, context = newSqlParseContext(), qualifySql) {
+  const previousWindows = context.windows;
+  const previousNextWindowId = context.nextWindowId;
+  const previousQualifySql = context.qualifySql;
+  context.windows = {};
+  context.nextWindowId = 0;
+  if (qualifySql === void 0)
+    delete context.qualifySql;
+  else
+    context.qualifySql = qualifySql;
+  const ast = selectStatementToAstInScope(statement, context);
+  context.windows = previousWindows;
+  context.nextWindowId = previousNextWindowId;
+  if (previousQualifySql === void 0)
+    delete context.qualifySql;
+  else
+    context.qualifySql = previousQualifySql;
+  return ast;
+}
+function selectStatementToAstInScope(statement, context) {
   rejectPresent(statement, "with", "CTEs are not supported");
   rejectPresent(statement, "windows", "Window functions are not supported");
   const from = optionalArray(statement.from);
@@ -7389,6 +7907,7 @@ function selectStatementToAst(statement, context = newSqlParseContext()) {
   const select = [];
   const projections = {};
   const aggregates = {};
+  const outputAliases = /* @__PURE__ */ new Set();
   for (const column of columns) {
     const item = asNode(column, "select item");
     const expr = asNode(item.expr, "select expression");
@@ -7398,14 +7917,24 @@ function selectStatementToAst(statement, context = newSqlParseContext()) {
       select.push("*");
       continue;
     }
+    if (expr.type === "call" && hasWindowOver(expr)) {
+      const alias2 = aliasName(item.alias) ?? syntheticWindowAlias(context);
+      ensureUniqueOutputAlias(alias2, outputAliases);
+      context.windows[alias2] = windowCallToExpr(expr, scope, context);
+      select.push(alias2);
+      continue;
+    }
     if (expr.type === "call" && isAggregateCall(expr)) {
       const alias2 = aliasName(item.alias) ?? functionName(expr.function);
+      ensureUniqueOutputAlias(alias2, outputAliases);
       aggregates[alias2] = aggregateCallToSpec(expr, scope, context);
       continue;
     }
     if (expr.type === "ref") {
       const name = scope.refName(expr);
       const alias2 = aliasName(item.alias);
+      const output = alias2 === void 0 ? name : alias2;
+      ensureUniqueOutputAlias(output, outputAliases);
       if (alias2 === void 0 || alias2 === name)
         select.push(name);
       else
@@ -7416,6 +7945,7 @@ function selectStatementToAst(statement, context = newSqlParseContext()) {
     if (alias === void 0) {
       throwUnsupported("Computed projections require an explicit alias");
     }
+    ensureUniqueOutputAlias(alias, outputAliases);
     projections[alias] = exprToLakeql(expr, scope, context);
   }
   if (select.length > 0)
@@ -7437,6 +7967,11 @@ function selectStatementToAst(statement, context = newSqlParseContext()) {
   if (statement.having !== void 0) {
     ast.having = exprToLakeql(asNode(statement.having, "HAVING"), scope, context);
   }
+  if (context.qualifySql !== void 0) {
+    ast.qualify = qualifyToExpr(context.qualifySql, scope, context);
+  }
+  if (Object.keys(context.windows).length > 0)
+    ast.windows = context.windows;
   if (statement.orderBy !== void 0) {
     ast.orderBy = optionalArray(statement.orderBy).map((term) => orderByToTerm(term, scope));
   }
@@ -7453,10 +7988,27 @@ function selectStatementToAst(statement, context = newSqlParseContext()) {
   }
   return ast;
 }
+function qualifyToExpr(sql, scope, context) {
+  let statements;
+  try {
+    statements = (0, import_pgsql_ast_parser.parse)(`select * from __lakeql_qualify where ${sql}`);
+  } catch (error) {
+    if (error instanceof Error)
+      throwParse(error.message);
+    throwParse("Invalid QUALIFY clause");
+  }
+  const statement = asNode(statements[0], "QUALIFY wrapper");
+  const where = asNode(statement.where, "QUALIFY predicate");
+  return exprToLakeql(where, scope, context);
+}
 function newSqlParseContext(options = {}) {
   return {
     scalarSubqueries: {},
     nextScalarSubqueryId: 0,
+    windows: {},
+    nextWindowId: 0,
+    windowFrames: [],
+    nextWindowFrameId: 0,
     ...options.parameters === void 0 ? {} : { parameters: options.parameters }
   };
 }
@@ -7483,9 +8035,11 @@ function exprToLakeql(expr, scope = SqlScope.empty(), context = newSqlParseConte
       return caseToExpr(expr, scope, context);
     case "select":
       return scalarSubqueryToExpr(expr, context);
+    case "cast":
+      return castToExpr(expr, scope, context);
     case "call":
       if ("over" in expr && expr.over !== void 0) {
-        throwUnsupported("Window functions are not supported");
+        return { kind: "column", name: registerSyntheticWindow(expr, scope, context) };
       }
       return {
         kind: "call",
@@ -7496,6 +8050,17 @@ function exprToLakeql(expr, scope = SqlScope.empty(), context = newSqlParseConte
       throwUnsupported(`Unsupported SQL expression ${String(expr.type)}`);
   }
 }
+function castToExpr(expr, scope = SqlScope.empty(), context = newSqlParseContext()) {
+  const target = String(asNode(expr.to, "cast target").name ?? "").toLowerCase();
+  if (target === "interval") {
+    const operand = exprToLakeql(asNode(expr.operand, "interval literal"), scope, context);
+    if (operand.kind !== "literal" || typeof operand.value !== "string") {
+      throwType("INTERVAL requires a string literal", { target });
+    }
+    return literal(intervalValue(operand.value));
+  }
+  throwUnsupported(`Unsupported SQL cast to ${target}`);
+}
 function binaryToExpr(expr, scope = SqlScope.empty(), context = newSqlParseContext()) {
   const op = String(expr.op).toUpperCase();
   const left = exprToLakeql(asNode(expr.left, "left expression"), scope, context);
@@ -7713,6 +8278,215 @@ function aggregateCallToSpec(expr, scope = SqlScope.empty(), context = newSqlPar
     return { op, column: scope.refName(arg) };
   return { op, expr: exprToLakeql(arg, scope, context) };
 }
+function hasWindowOver(expr) {
+  return "over" in expr && expr.over !== void 0;
+}
+function registerSyntheticWindow(expr, scope, context) {
+  const alias = syntheticWindowAlias(context);
+  context.windows[alias] = windowCallToExpr(expr, scope, context);
+  return alias;
+}
+function syntheticWindowAlias(context) {
+  const alias = `__lakeql_window_${context.nextWindowId}`;
+  context.nextWindowId += 1;
+  return alias;
+}
+function ensureUniqueOutputAlias(alias, aliases) {
+  if (PROTOTYPE_MUTATION_KEYS.has(alias))
+    throwUnsupported(`Unsafe SELECT output alias ${alias}`);
+  if (aliases.has(alias))
+    throwUnsupported(`Duplicate SELECT output alias ${alias}`);
+  aliases.add(alias);
+}
+function windowCallToExpr(expr, scope, context) {
+  if (!hasWindowOver(expr))
+    throwUnsupported("Window call requires OVER");
+  const args = optionalArray(expr.args);
+  const fnName = functionName(expr.function);
+  let aggregate = aggregateOpOrUndefined(fnName);
+  if (expr.distinct !== void 0) {
+    if (expr.distinct !== "distinct") {
+      throwUnsupported("Only DISTINCT window arguments are supported");
+    }
+    if (aggregate !== "count")
+      throwUnsupported("Only COUNT(DISTINCT x) window arguments are supported");
+    aggregate = "count_distinct";
+  }
+  const windowFn = aggregate === void 0 ? windowFunctionName(fnName) : { aggregate };
+  const over = callOverToWindowSpec(asNode(expr.over, "OVER clause"), scope, context);
+  const out = {
+    fn: windowFn,
+    args: args.filter((arg) => !isWildcard(asNode(arg, "window argument"))).map((arg) => exprToLakeql(asNode(arg, "window argument"), scope, context)),
+    over: over.spec
+  };
+  if (over.ignoreNulls !== void 0)
+    out.ignoreNulls = over.ignoreNulls;
+  if (expr.filter !== void 0) {
+    out.filter = exprToLakeql(asNode(expr.filter, "window FILTER predicate"), scope, context);
+  }
+  return out;
+}
+function windowFunctionName(name) {
+  switch (name.toLowerCase()) {
+    case "row_number":
+    case "rank":
+    case "dense_rank":
+    case "percent_rank":
+    case "cume_dist":
+    case "ntile":
+    case "lag":
+    case "lead":
+    case "first_value":
+    case "last_value":
+    case "nth_value":
+      return name.toLowerCase();
+    default:
+      throwUnsupported(`Unsupported window function ${name}`);
+  }
+}
+function callOverToWindowSpec(over, scope, context) {
+  rejectPresent(over, "name", "Named windows require the window pre-pass");
+  const prepass = nextWindowFrame(context);
+  const spec = {
+    partitionBy: optionalArray(over.partitionBy).map((expr) => exprToLakeql(asNode(expr, "window PARTITION BY expression"), scope, context)),
+    orderBy: optionalArray(over.orderBy).map((term) => windowOrderByToTerm(term, scope, context))
+  };
+  if (prepass?.text !== void 0)
+    spec.frame = frameTextToSpec(prepass.text, scope, context);
+  return prepass?.ignoreNulls === void 0 ? { spec } : { spec, ignoreNulls: prepass.ignoreNulls };
+}
+function nextWindowFrame(context) {
+  const frame = context.windowFrames[context.nextWindowFrameId];
+  context.nextWindowFrameId += 1;
+  return frame;
+}
+function frameTextToSpec(text, scope, context) {
+  const { body, exclude } = splitFrameExclude(text);
+  const modeMatch = /^(rows|range|groups)\b/iu.exec(body.trim());
+  if (modeMatch === null || modeMatch[1] === void 0) {
+    throwParse("Window frame must start with ROWS, RANGE, or GROUPS");
+  }
+  const mode = modeMatch[1].toLowerCase();
+  const rest = body.trim().slice(modeMatch[0].length).trim();
+  const bounds = frameBounds(rest, scope, context);
+  return { mode, ...bounds, exclude };
+}
+function splitFrameExclude(text) {
+  const match = /\bexclude\s+(no\s+others|current\s+row|group|ties)\s*$/iu.exec(text);
+  if (match === null)
+    return { body: text, exclude: "no-others" };
+  const value2 = String(match[1]).toLowerCase().replace(/\s+/gu, "-");
+  const exclude = value2 === "no-others" || value2 === "current-row" || value2 === "group" || value2 === "ties" ? value2 : "no-others";
+  return { body: text.slice(0, match.index).trim(), exclude };
+}
+function frameBounds(text, scope, context) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return { start: { kind: "unbounded-preceding" }, end: { kind: "current-row" } };
+  }
+  if (/^between\b/iu.test(trimmed)) {
+    const between = trimmed.replace(/^between\b/iu, "").trim();
+    const andIndex = findTopLevelAnd(between);
+    if (andIndex === -1)
+      throwParse("Window frame BETWEEN requires AND");
+    return {
+      start: frameBound(between.slice(0, andIndex).trim(), scope, context),
+      end: frameBound(between.slice(andIndex + "and".length).trim(), scope, context)
+    };
+  }
+  return {
+    start: frameBound(trimmed, scope, context),
+    end: { kind: "current-row" }
+  };
+}
+function frameBound(text, scope, context) {
+  if (/^unbounded\s+preceding$/iu.test(text))
+    return { kind: "unbounded-preceding" };
+  if (/^unbounded\s+following$/iu.test(text))
+    return { kind: "unbounded-following" };
+  if (/^current\s+row$/iu.test(text))
+    return { kind: "current-row" };
+  const preceding = /\bpreceding$/iu.exec(text);
+  if (preceding !== null) {
+    return {
+      kind: "preceding",
+      offset: parseFrameOffset(text.slice(0, preceding.index).trim(), scope, context)
+    };
+  }
+  const following = /\bfollowing$/iu.exec(text);
+  if (following !== null) {
+    return {
+      kind: "following",
+      offset: parseFrameOffset(text.slice(0, following.index).trim(), scope, context)
+    };
+  }
+  throwParse(`Unsupported window frame bound ${text}`);
+}
+function parseFrameOffset(text, scope, context) {
+  if (text.length === 0)
+    throwParse("Window frame offset is required");
+  let statements;
+  try {
+    statements = (0, import_pgsql_ast_parser.parse)(`select ${text} as frame_offset from __lakeql_frame`);
+  } catch (error) {
+    if (error instanceof Error)
+      throwParse(error.message);
+    throwParse("Invalid window frame offset");
+  }
+  const statement = asNode(statements[0], "frame offset wrapper");
+  const column = asNode(optionalArray(statement.columns)[0], "frame offset column");
+  return exprToLakeql(asNode(column.expr, "frame offset expression"), scope, context);
+}
+function findTopLevelAnd(text) {
+  let depth = 0;
+  let quote;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (quote !== void 0) {
+      if (char === quote) {
+        if (next === quote) {
+          index += 1;
+          continue;
+        }
+        quote = void 0;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(")
+      depth += 1;
+    else if (char === ")")
+      depth = Math.max(0, depth - 1);
+    if (depth === 0 && text.slice(index, index + "and".length).toLowerCase() === "and" && /(?:^|[^A-Za-z0-9_])$/u.test(text.slice(0, index)) && !/[A-Za-z0-9_]/u.test(text[index + "and".length] ?? "")) {
+      return index;
+    }
+  }
+  return -1;
+}
+function windowOrderByToTerm(value2, scope, context) {
+  const node = asNode(value2, "window ORDER BY term");
+  const term = {
+    expr: exprToLakeql(asNode(node.by, "window ORDER BY expression"), scope, context)
+  };
+  if (node.order !== void 0) {
+    const order = String(node.order).toLowerCase();
+    if (order !== "asc" && order !== "desc")
+      throwUnsupported(`Unsupported ORDER BY ${order}`);
+    term.direction = order;
+  }
+  if (node.nulls !== void 0) {
+    const nulls = String(node.nulls).toLowerCase();
+    if (nulls !== "first" && nulls !== "last") {
+      throwUnsupported(`Unsupported ORDER BY NULLS ${nulls}`);
+    }
+    term.nulls = nulls;
+  }
+  return term;
+}
 function quantileAggregateCallToSpec(args, scope, context) {
   if (args.length !== 2)
     throwUnsupported("quantile_cont requires value and percentile arguments");
@@ -7734,6 +8508,8 @@ function requiredQuantilePercentile(expr) {
 function isAggregateCall(expr) {
   if (expr.type !== "call")
     return false;
+  if (hasWindowOver(expr))
+    return false;
   return aggregateOpOrUndefined(functionName(expr.function)) !== void 0;
 }
 function isAggregateOp(op) {
@@ -8005,7 +8781,7 @@ function parameterIndex(name) {
   return Number(name.slice(1));
 }
 function isScalar(value2) {
-  return value2 === null || typeof value2 === "string" || typeof value2 === "boolean" || typeof value2 === "bigint" || isTimestampValue(value2) || typeof value2 === "number" && Number.isFinite(value2);
+  return value2 === null || typeof value2 === "string" || typeof value2 === "boolean" || typeof value2 === "bigint" || isTimestampValue(value2) || isIntervalValue(value2) || typeof value2 === "number" && Number.isFinite(value2);
 }
 function assertAstDepth(value2, depth = 0) {
   if (depth > MAX_AST_DEPTH)
@@ -8109,31 +8885,31 @@ async function query(args) {
   const resolvedAst = await resolveScalarSubqueries(executableLake, executableAst);
   if (resolvedAst.subqueryJoin !== void 0) {
     const rows = await subqueryJoinRowsFromAst(executableLake, resolvedAst, args);
-    if (args.format === "json") return `${JSON.stringify(rows)}
+    if (args.format === "json") return `${jsonStringify(rows)}
 `;
     if (args.format === "csv") return rowsToCsv(rows);
-    return rows.map((row) => JSON.stringify(row)).join("\n") + (rows.length > 0 ? "\n" : "");
+    return rows.map((row) => jsonStringify(row)).join("\n") + (rows.length > 0 ? "\n" : "");
   }
   if (resolvedAst.join !== void 0) {
     const rows = await joinRowsFromAst(executableLake, resolvedAst, args);
-    if (args.format === "json") return `${JSON.stringify(rows)}
+    if (args.format === "json") return `${jsonStringify(rows)}
 `;
     if (args.format === "csv") return rowsToCsv(rows);
-    return rows.map((row) => JSON.stringify(row)).join("\n") + (rows.length > 0 ? "\n" : "");
+    return rows.map((row) => jsonStringify(row)).join("\n") + (rows.length > 0 ? "\n" : "");
   }
   const result2 = builderFromAst(executableLake.path(resolvedAst.source), resolvedAst);
   if (hasAggregation(resolvedAst)) {
     const rows = await aggregateRowsFromAst(executableLake.path(resolvedAst.source), resolvedAst);
-    if (args.format === "json") return `${JSON.stringify(rows)}
+    if (args.format === "json") return `${jsonStringify(rows)}
 `;
     if (args.format === "csv") return rowsToCsv(rows);
-    return rows.map((row) => JSON.stringify(row)).join("\n") + (rows.length > 0 ? "\n" : "");
+    return rows.map((row) => jsonStringify(row)).join("\n") + (rows.length > 0 ? "\n" : "");
   }
-  if (args.format === "json") return `${JSON.stringify(await result2.toArray())}
+  if (args.format === "json") return `${jsonStringify(await result2.toArray())}
 `;
   if (args.format === "csv") return new Response(result2.streamCsv()).text();
   let out = "";
-  for await (const row of result2.rows()) out += `${JSON.stringify(row)}
+  for await (const row of result2.rows()) out += `${jsonStringify(row)}
 `;
   return out;
 }
@@ -8160,14 +8936,14 @@ async function compact(args) {
 async function schema(args) {
   const path = requireOption(args.path, "--path");
   const { store, key } = await localStore(path);
-  return `${JSON.stringify(await schemaSummary(store, key, path))}
+  return `${jsonStringify(await schemaSummary(store, key, path))}
 `;
 }
 async function inspect(args) {
   const path = requireOption(args.path, "--path");
   const { store, key } = await localStore(path);
   const metadata = await readParquetMetadata(store, key);
-  return `${JSON.stringify({
+  return `${jsonStringify({
     path,
     rows: Number(totalRows(metadata.row_groups)),
     rowGroups: metadata.row_groups.length,
@@ -8233,14 +9009,16 @@ async function writeRows(outputPrefix, rows, args) {
     await writeFile(args.manifest, bytes);
     body.manifest = args.manifest;
   }
-  return `${JSON.stringify(body)}
+  return `${jsonStringify(body)}
 `;
 }
 function builderFromAst(builder, ast) {
   let next = builder;
+  for (const [alias, expr] of Object.entries(ast.windows ?? {})) next = next.window(alias, expr);
   if (ast.select) next = next.select(ast.select);
   if (ast.projections) next = next.project(ast.projections);
   if (ast.where) next = next.where(ast.where);
+  if (ast.qualify) next = next.qualify(ast.qualify);
   if (ast.distinct === true) next = next.distinct();
   if (ast.orderBy) next = next.orderBy(ast.orderBy);
   if (ast.offset !== void 0) next = next.offset(ast.offset);
@@ -8250,6 +9028,9 @@ function builderFromAst(builder, ast) {
 function hasAggregation(ast) {
   return ast.aggregates !== void 0 || ast.groupBy !== void 0 && ast.groupBy.length > 0 || ast.having !== void 0;
 }
+function hasWindowSemantics(ast) {
+  return ast.windows !== void 0 && Object.keys(ast.windows).length > 0 || ast.qualify !== void 0;
+}
 async function materializeCteIfNeeded(store, lake, ast) {
   if (ast.cte === void 0) return ast;
   if (ast.source !== ast.cte.name) {
@@ -8361,6 +9142,9 @@ function replaceScalarSubqueryExpr(expr, values) {
 async function joinRowsFromAst(lake, ast, args) {
   if (ast.join === void 0) throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Missing SQL JOIN");
   const join = ast.join;
+  if (hasWindowSemantics(ast)) {
+    throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", "Window SQL over JOIN is not supported");
+  }
   if (hasAggregation(ast)) {
     throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", "Aggregate SQL over JOIN is not supported yet");
   }
@@ -8606,6 +9390,9 @@ async function subqueryJoinRowsFromAst(lake, ast, args) {
   if (ast.subqueryJoin === void 0) {
     throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Missing SQL IN subquery");
   }
+  if (hasWindowSemantics(ast)) {
+    throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", "Window SQL over IN subquery is not supported");
+  }
   if (hasAggregation(ast)) {
     throw new LakeqlError(
       "LAKEQL_SQL_UNSUPPORTED",
@@ -8659,6 +9446,9 @@ function projectRows(rows, ast) {
   });
 }
 async function aggregateRowsFromAst(builder, ast) {
+  if (hasWindowSemantics(ast)) {
+    throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", "Window SQL over aggregates is not supported");
+  }
   validateAggregateProjection(ast);
   let next = builder;
   if (ast.where) next = next.where(ast.where);
@@ -8762,10 +9552,13 @@ function rowsToCsv(rows) {
 `;
 }
 function formatRows(rows, format) {
-  if (format === "json") return `${JSON.stringify(rows)}
+  if (format === "json") return `${jsonStringify(rows)}
 `;
   if (format === "csv") return rowsToCsv(rows);
-  return rows.map((row) => JSON.stringify(row)).join("\n") + (rows.length > 0 ? "\n" : "");
+  return rows.map((row) => jsonStringify(row)).join("\n") + (rows.length > 0 ? "\n" : "");
+}
+function jsonStringify(value2) {
+  return JSON.stringify(value2, (_key, item) => typeof item === "bigint" ? item.toString() : item);
 }
 async function schemaSummary(store, key, displayPath = key) {
   const metadata = await readParquetMetadata(store, key);