@quereus/quereus 0.17.0 → 0.18.0

package/dist/src/runtime/emit/window.js

@@ -2,10 +2,11 @@ import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
 import { resolveWindowFunction } from '../../schema/window-function.js';
 import { QuereusError } from '../../common/errors.js';
 import { StatusCode } from '../../common/types.js';
-import { compareSqlValues, createOrderByComparatorFast, resolveCollation } from '../../util/comparison.js';
+import { createTypedComparator, createOrderByComparatorFast } from '../../util/comparison.js';
+import { resolveKeyNormalizer, serializeKeyNullGrouping } from '../../util/key-serializer.js';
 import { createLogger } from '../../common/logger.js';
 import { buildRowDescriptor } from '../../util/row-descriptor.js';
-import { withRowContext, withAsyncRowContext } from '../context-helpers.js';
+import { createRowSlot } from '../context-helpers.js';
 const log = createLogger('runtime:emit:window');
 export function emitWindow(plan, ctx) {
     // Get schemas for all window functions in this node
@@ -20,39 +21,71 @@ export function emitWindow(plan, ctx) {
     const partitionCallbacks = plan.partitionExpressions.map(exprPlan => emitCallFromPlan(exprPlan, ctx));
     // Emit callbacks for ORDER BY expressions (if any)
     const orderByCallbacks = plan.orderByExpressions.map(exprPlan => emitCallFromPlan(exprPlan, ctx));
-    // Emit callbacks for window function arguments
-    const functionArgCallbacks = plan.functionArguments.map(argPlan => argPlan ? emitCallFromPlan(argPlan, ctx) : null);
+    // Emit callbacks for window function arguments (2D: per-function arrays)
+    const functionArgCallbacks = plan.functionArguments.map(argPlans => argPlans.map(argPlan => emitCallFromPlan(argPlan, ctx)));
+    // Track per-function arg counts for callback reconstruction in run()
+    const functionArgCounts = plan.functionArguments.map(args => args.length);
     // Create row descriptors
     const sourceRowDescriptor = buildRowDescriptor(plan.source.getAttributes());
-    const outputRowDescriptor = buildRowDescriptor(plan.getAttributes());
+    // Pre-resolve ORDER BY comparators using actual expression types (not hardcoded BINARY)
+    const orderByComparators = plan.orderByExpressions.map((exprPlan, i) => {
+        const exprType = exprPlan.getType();
+        const collationName = exprType.collationName || 'BINARY';
+        const collationFunc = ctx.resolveCollation(collationName);
+        const orderClause = plan.windowSpec.orderBy[i];
+        return createOrderByComparatorFast(orderClause.direction, orderClause.nulls, collationFunc);
+    });
+    // Pre-resolve typed equality comparators for ORDER BY (used in ranking functions)
+    const orderByEqualityComparators = plan.orderByExpressions.map(exprPlan => {
+        const exprType = exprPlan.getType();
+        const collationFunc = exprType.collationName ? ctx.resolveCollation(exprType.collationName) : undefined;
+        return createTypedComparator(exprType.logicalType, collationFunc);
+    });
+    // Pre-resolve collation normalizers for partition key serialization
+    const partitionKeyNormalizers = plan.partitionExpressions.map(exprPlan => resolveKeyNormalizer(exprPlan.getType().collationName));
+    // Pre-resolve collation normalizers for ORDER BY key serialization (dense_rank dedup)
+    const orderByKeyNormalizers = plan.orderByExpressions.map(exprPlan => resolveKeyNormalizer(exprPlan.getType().collationName));
     async function* run(rctx, source, ...callbacks) {
         log('Starting window function execution');
         // Extract callbacks in order: partitions, orderBy, function args
         const partitionCallbackList = callbacks.slice(0, partitionCallbacks.length);
         const orderByCallbackList = callbacks.slice(partitionCallbacks.length, partitionCallbacks.length + orderByCallbacks.length);
-        const funcArgCallbackList = callbacks.slice(partitionCallbacks.length + orderByCallbacks.length);
+        // Reconstruct per-function arg callback arrays from flattened list
+        const funcArgCallbackGroups = [];
+        let argOffset = partitionCallbacks.length + orderByCallbacks.length;
+        for (const count of functionArgCounts) {
+            funcArgCallbackGroups.push(callbacks.slice(argOffset, argOffset + count));
+            argOffset += count;
+        }
         // Collect all rows (window functions require materialization for frame evaluation)
         const allRows = [];
         for await (const row of source) {
             allRows.push(row);
         }
-        if (plan.windowSpec.partitionBy.length === 0) {
-            // No partitioning - process as single partition
-            yield* processPartition(allRows, plan, functionSchemas, rctx, sourceRowDescriptor, outputRowDescriptor, partitionCallbackList, orderByCallbackList, funcArgCallbackList);
-        }
-        else {
-            // With partitioning - group by partition keys
-            const partitions = await groupByPartitions(allRows, partitionCallbackList, rctx, sourceRowDescriptor);
-            for (const partitionRows of partitions.values()) {
-                yield* processPartition(partitionRows, plan, functionSchemas, rctx, sourceRowDescriptor, outputRowDescriptor, partitionCallbackList, orderByCallbackList, funcArgCallbackList);
+        // Single source slot shared across all partition/sort/ranking/aggregate operations
+        const sourceSlot = createRowSlot(rctx, sourceRowDescriptor);
+        try {
+            if (plan.windowSpec.partitionBy.length === 0) {
+                // No partitioning - process as single partition
+                yield* processPartition(allRows, plan, functionSchemas, rctx, sourceRowDescriptor, partitionCallbackList, orderByCallbackList, funcArgCallbackGroups, sourceSlot, orderByComparators, orderByEqualityComparators, orderByKeyNormalizers);
             }
+            else {
+                // With partitioning - group by partition keys
+                const partitions = await groupByPartitions(allRows, partitionCallbackList, rctx, sourceSlot, partitionKeyNormalizers);
+                for (const partitionRows of partitions.values()) {
+                    yield* processPartition(partitionRows, plan, functionSchemas, rctx, sourceRowDescriptor, partitionCallbackList, orderByCallbackList, funcArgCallbackGroups, sourceSlot, orderByComparators, orderByEqualityComparators, orderByKeyNormalizers);
+                }
+            }
+        }
+        finally {
+            sourceSlot.close();
         }
     }
-    // Collect all callbacks
+    // Collect all callbacks (flatten per-function arg arrays)
     const allCallbacks = [
         ...partitionCallbacks,
         ...orderByCallbacks,
-        ...functionArgCallbacks.filter(cb => cb !== null)
+        ...functionArgCallbacks.flat()
     ];
     const sourceInstruction = emitPlanNode(plan.source, ctx);
     return {
@@ -61,15 +94,12 @@ export function emitWindow(plan, ctx) {
         note: `window(${plan.functions.map(f => f.functionName).join(', ')})`
     };
 }
-async function groupByPartitions(rows, partitionCallbacks, rctx, sourceRowDescriptor) {
+async function groupByPartitions(rows, partitionCallbacks, rctx, sourceSlot, keyNormalizers) {
     const partitions = new Map();
     for (const row of rows) {
-        const partitionKey = await withAsyncRowContext(rctx, sourceRowDescriptor, () => row, async () => {
-            // Evaluate partition expressions
-            const partitionValues = await Promise.all(partitionCallbacks.map(callback => callback(rctx)));
-            // Create partition key
-            return partitionValues.map(val => val === null ? 'NULL' : String(val)).join('|');
-        });
+        sourceSlot.set(row);
+        const partitionValues = await Promise.all(partitionCallbacks.map(callback => callback(rctx)));
+        const partitionKey = serializeKeyNullGrouping(partitionValues, keyNormalizers);
         if (!partitions.has(partitionKey)) {
             partitions.set(partitionKey, []);
         }
@@ -77,59 +107,59 @@ async function groupByPartitions(rows, partitionCallbacks, rctx, sourceRowDescri
     }
     return partitions;
 }
-async function* processPartition(partitionRows, plan, functionSchemas, rctx, sourceRowDescriptor, outputRowDescriptor, partitionCallbacks, orderByCallbacks, funcArgCallbacks) {
+async function* processPartition(partitionRows, plan, functionSchemas, rctx, sourceRowDescriptor, partitionCallbacks, orderByCallbacks, funcArgCallbackGroups, sourceSlot, preResolvedOrderByComparators, preResolvedEqualityComparators, orderByKeyNormalizers) {
     // Sort rows according to ORDER BY specification
-    const sortedRows = await sortRows(partitionRows, plan.windowSpec.orderBy, orderByCallbacks, rctx, sourceRowDescriptor);
+    const sorted = await sortRows(partitionRows, plan.windowSpec.orderBy, orderByCallbacks, rctx, sourceSlot, preResolvedOrderByComparators);
+    const sortedRows = sorted.rows;
+    const orderByValues = sorted.orderByValues;
+    const partitionSize = sortedRows.length;
     // Process each row in the sorted partition
     for (let currentIndex = 0; currentIndex < sortedRows.length; currentIndex++) {
         const currentRow = sortedRows[currentIndex];
         const outputRow = [...currentRow];
-        // Set up context for current row
-        const outputValues = await withRowContext(rctx, sourceRowDescriptor, () => currentRow, async () => {
-            const values = [];
-            // Compute each window function
-            for (let funcIndex = 0; funcIndex < plan.functions.length; funcIndex++) {
-                const func = plan.functions[funcIndex];
-                const schema = functionSchemas[funcIndex];
-                const argCallback = funcArgCallbacks[funcIndex];
-                let value;
-                if (schema.kind === 'ranking') {
-                    value = await computeRankingFunction(func.functionName, sortedRows, currentIndex, orderByCallbacks, rctx, sourceRowDescriptor);
-                }
-                else if (schema.kind === 'aggregate') {
-                    value = await computeAggregateFunction(schema, argCallback, sortedRows, currentIndex, plan.windowSpec.frame, plan.windowSpec.orderBy.length > 0, rctx, sourceRowDescriptor);
-                }
-                else {
-                    throw new QuereusError(`Window function type ${schema.kind} not yet implemented`, StatusCode.UNSUPPORTED);
-                }
-                values.push(value);
+        // Set source context for current row
+        sourceSlot.set(currentRow);
+        const values = [];
+        // Compute each window function
+        for (let funcIndex = 0; funcIndex < plan.functions.length; funcIndex++) {
+            const func = plan.functions[funcIndex];
+            const schema = functionSchemas[funcIndex];
+            const argCallbacks = funcArgCallbackGroups[funcIndex];
+            let value;
+            if (schema.kind === 'ranking') {
+                value = await computeRankingFunction(func.functionName, sortedRows, currentIndex, partitionSize, argCallbacks, orderByCallbacks, rctx, sourceSlot, preResolvedEqualityComparators, orderByKeyNormalizers);
+            }
+            else if (schema.kind === 'aggregate') {
+                value = await computeAggregateFunction(schema, argCallbacks[0] ?? null, sortedRows, currentIndex, plan.windowSpec.frame, plan.windowSpec.orderBy.length > 0, orderByValues, preResolvedEqualityComparators, rctx, sourceSlot);
+            }
+            else if (schema.kind === 'navigation') {
+                value = await computeNavigationFunction(func.functionName, sortedRows, currentIndex, argCallbacks, rctx, sourceSlot);
             }
-            return values;
-        });
+            else if (schema.kind === 'value') {
+                value = await computeValueFunction(func.functionName, sortedRows, currentIndex, argCallbacks, plan.windowSpec.frame, plan.windowSpec.orderBy.length > 0, orderByValues, preResolvedEqualityComparators, rctx, sourceSlot);
+            }
+            else {
+                throw new QuereusError(`Window function type ${schema.kind} not yet implemented`, StatusCode.UNSUPPORTED);
+            }
+            // Restore current row context after helper may have changed it
+            sourceSlot.set(currentRow);
+            values.push(value);
+        }
         // Add computed values to output row
-        outputRow.push(...outputValues);
-        // Yield the output row
-        yield await withRowContext(rctx, outputRowDescriptor, () => outputRow, () => outputRow);
+        outputRow.push(...values);
+        yield outputRow;
     }
 }
-async function sortRows(rows, orderBy, orderByCallbacks, rctx, sourceRowDescriptor) {
+async function sortRows(rows, orderBy, orderByCallbacks, rctx, sourceSlot, preResolvedComparators) {
     if (orderBy.length === 0) {
-        return rows; // No sorting needed
+        return { rows, orderByValues: rows.map(() => []) };
     }
-    // Pre-create optimized comparators for all ORDER BY expressions with resolved collations
-    const orderByComparators = orderBy.map(orderClause => {
-        // TODO: Extract actual collation from order clause expression
-        // For now, use BINARY collation (most common case)
-        const collationFunc = resolveCollation('BINARY');
-        return createOrderByComparatorFast(orderClause.direction, orderClause.nulls, collationFunc);
-    });
     // Pre-evaluate ORDER BY values for all rows to avoid async in sort
     const rowsWithValues = await Promise.all(rows.map(async (row) => {
+        sourceSlot.set(row);
         const values = await Promise.all(orderByCallbacks.map(async (callback) => {
-            return await withAsyncRowContext(rctx, sourceRowDescriptor, () => row, async () => {
-                const result = callback(rctx);
-                return await Promise.resolve(result);
-            });
+            const result = callback(rctx);
+            return await Promise.resolve(result);
         }));
         return { row, values };
     }));
@@ -137,7 +167,7 @@ async function sortRows(rows, orderBy, orderByCallbacks, rctx, sourceRowDescript
     rowsWithValues.sort((a, b) => {
         // Compare each ORDER BY expression in sequence
         for (let i = 0; i < orderBy.length; i++) {
-            const comparator = orderByComparators[i];
+            const comparator = preResolvedComparators[i];
             const valueA = a.values[i];
             const valueB = b.values[i];
             // Use pre-created optimized comparator
@@ -150,24 +180,17 @@ async function sortRows(rows, orderBy, orderByCallbacks, rctx, sourceRowDescript
         }
         return 0; // All ORDER BY expressions are equal
     });
-    // Extract just the rows in sorted order
-    return rowsWithValues.map(item => item.row);
+    return {
+        rows: rowsWithValues.map(item => item.row),
+        orderByValues: rowsWithValues.map(item => item.values)
+    };
 }
-async function computeRankingFunction(functionName, sortedRows, currentIndex, orderByCallbacks, rctx, sourceRowDescriptor) {
+async function computeRankingFunction(functionName, sortedRows, currentIndex, partitionSize, argCallbacks, orderByCallbacks, rctx, sourceSlot, equalityComparators, orderByKeyNormalizers) {
     switch (functionName.toLowerCase()) {
         case 'row_number':
             return currentIndex + 1;
         case 'rank': {
-            // Find rank by counting how many rows come before this one in sort order
-            let rank = 1;
-            const currentRow = sortedRows[currentIndex];
-            for (let i = 0; i < currentIndex; i++) {
-                const prevRow = sortedRows[i];
-                if (!(await areRowsEqualInOrderBy(prevRow, currentRow, orderByCallbacks, rctx, sourceRowDescriptor))) {
-                    rank = i + 2; // Rank is 1-based and accounts for ties
-                }
-            }
-            return rank;
+            return computeRank(sortedRows, currentIndex, orderByCallbacks, rctx, sourceSlot, equalityComparators);
         }
         case 'dense_rank': {
             // Count distinct values that come before this one
@@ -176,9 +199,9 @@ async function computeRankingFunction(functionName, sortedRows, currentIndex, or
             const seenValues = new Set();
             for (let i = 0; i < currentIndex; i++) {
                 const prevRow = sortedRows[i];
-                if (!(await areRowsEqualInOrderBy(prevRow, currentRow, orderByCallbacks, rctx, sourceRowDescriptor))) {
+                if (!(await areRowsEqualInOrderBy(prevRow, currentRow, orderByCallbacks, rctx, sourceSlot, equalityComparators))) {
                     // Create a key for this distinct set of ORDER BY values
-                    const key = await getOrderByKey(prevRow, orderByCallbacks, rctx, sourceRowDescriptor);
+                    const key = await getOrderByKey(prevRow, orderByCallbacks, rctx, sourceSlot, orderByKeyNormalizers);
                     if (!seenValues.has(key)) {
                         seenValues.add(key);
                         denseRank++;
@@ -187,36 +210,134 @@ async function computeRankingFunction(functionName, sortedRows, currentIndex, or
             }
             return denseRank;
         }
+        case 'ntile': {
+            // Evaluate the bucket count argument
+            const nValue = argCallbacks.length > 0
+                ? await Promise.resolve(argCallbacks[0](rctx))
+                : 1;
+            const n = Number(nValue) || 1;
+            if (n <= 0)
+                return 1;
+            // Divide partition into n roughly equal groups
+            const q = Math.floor(partitionSize / n);
+            const r = partitionSize % n;
+            // First r groups have (q+1) rows, remaining have q rows
+            if (currentIndex < r * (q + 1)) {
+                return Math.floor(currentIndex / (q + 1)) + 1;
+            }
+            else {
+                return r + Math.floor((currentIndex - r * (q + 1)) / q) + 1;
+            }
+        }
+        case 'percent_rank': {
+            if (partitionSize <= 1)
+                return 0;
+            const rank = await computeRank(sortedRows, currentIndex, orderByCallbacks, rctx, sourceSlot, equalityComparators);
+            return (rank - 1) / (partitionSize - 1);
+        }
+        case 'cume_dist': {
+            // CUME_DIST = (number of rows <= current row) / partitionSize
+            // = (index of last peer + 1) / partitionSize
+            const currentRow = sortedRows[currentIndex];
+            let lastPeerIndex = currentIndex;
+            for (let i = currentIndex + 1; i < partitionSize; i++) {
+                if (await areRowsEqualInOrderBy(sortedRows[i], currentRow, orderByCallbacks, rctx, sourceSlot, equalityComparators)) {
+                    lastPeerIndex = i;
+                }
+                else {
+                    break;
+                }
+            }
+            return (lastPeerIndex + 1) / partitionSize;
+        }
         default:
             throw new QuereusError(`Ranking function ${functionName} not implemented`, StatusCode.UNSUPPORTED);
     }
 }
-async function computeAggregateFunction(schema, argCallback, sortedRows, currentIndex, frame, hasOrderBy, rctx, sourceRowDescriptor) {
-    // Determine frame bounds
-    const frameBounds = getFrameBounds(frame, sortedRows.length, currentIndex, hasOrderBy);
+/** Compute RANK() value — extracted for reuse by PERCENT_RANK */
+async function computeRank(sortedRows, currentIndex, orderByCallbacks, rctx, sourceSlot, equalityComparators) {
+    let rank = 1;
+    const currentRow = sortedRows[currentIndex];
+    for (let i = 0; i < currentIndex; i++) {
+        const prevRow = sortedRows[i];
+        if (!(await areRowsEqualInOrderBy(prevRow, currentRow, orderByCallbacks, rctx, sourceSlot, equalityComparators))) {
+            rank = i + 2; // Rank is 1-based and accounts for ties
+        }
+    }
+    return rank;
+}
+async function computeNavigationFunction(functionName, sortedRows, currentIndex, argCallbacks, rctx, sourceSlot) {
+    const exprCallback = argCallbacks[0];
+    if (!exprCallback) {
+        throw new QuereusError(`${functionName} requires at least one argument`, StatusCode.ERROR);
+    }
+    // Evaluate offset (2nd arg, default 1)
+    let offset = 1;
+    if (argCallbacks.length >= 2) {
+        const offsetValue = await Promise.resolve(argCallbacks[1](rctx));
+        offset = Number(offsetValue) || 0;
+    }
+    // Evaluate default value (3rd arg, default null)
+    let defaultValue = null;
+    if (argCallbacks.length >= 3) {
+        defaultValue = await Promise.resolve(argCallbacks[2](rctx));
+    }
+    const name = functionName.toLowerCase();
+    const targetIndex = name === 'lag'
+        ? currentIndex - offset
+        : currentIndex + offset; // 'lead'
+    if (targetIndex < 0 || targetIndex >= sortedRows.length) {
+        return defaultValue;
+    }
+    // Evaluate expression on the target row
+    sourceSlot.set(sortedRows[targetIndex]);
+    return await Promise.resolve(exprCallback(rctx));
+}
+async function computeValueFunction(functionName, sortedRows, currentIndex, argCallbacks, frame, hasOrderBy, orderByValues, equalityComparators, rctx, sourceSlot) {
+    const exprCallback = argCallbacks[0];
+    if (!exprCallback) {
+        throw new QuereusError(`${functionName} requires one argument`, StatusCode.ERROR);
+    }
+    const frameBounds = getFrameBounds(frame, sortedRows.length, currentIndex, hasOrderBy, orderByValues, equalityComparators);
+    const name = functionName.toLowerCase();
+    let targetIndex;
+    if (name === 'first_value') {
+        targetIndex = frameBounds.start;
+    }
+    else {
+        // last_value
+        targetIndex = frameBounds.end;
+    }
+    // Handle empty frame
+    if (targetIndex < 0 || targetIndex >= sortedRows.length || frameBounds.start > frameBounds.end) {
+        return null;
+    }
+    sourceSlot.set(sortedRows[targetIndex]);
+    return await Promise.resolve(exprCallback(rctx));
+}
+async function computeAggregateFunction(schema, argCallback, sortedRows, currentIndex, frame, hasOrderBy, orderByValues, equalityComparators, rctx, sourceSlot) {
+    const frameBounds = getFrameBounds(frame, sortedRows.length, currentIndex, hasOrderBy, orderByValues, equalityComparators);
     let accumulator = null;
     let rowCount = 0;
     // Process rows within the frame
     for (let i = frameBounds.start; i <= frameBounds.end; i++) {
         const frameRow = sortedRows[i];
-        await withAsyncRowContext(rctx, sourceRowDescriptor, () => frameRow, async () => {
-            let argValue = null;
-            // Get argument value if callback exists
-            if (argCallback) {
-                const result = argCallback(rctx);
-                argValue = await Promise.resolve(result);
-            }
-            // Apply aggregate step function
-            if (schema.step) {
-                accumulator = schema.step(accumulator, argValue);
-                rowCount++;
-            }
-        });
+        sourceSlot.set(frameRow);
+        let argValue = null;
+        // Get argument value if callback exists
+        if (argCallback) {
+            argValue = await Promise.resolve(argCallback(rctx));
+        }
+        // Apply aggregate step function
+        if (schema.step) {
+            accumulator = schema.step(accumulator, argValue);
+            rowCount++;
+        }
     }
     // Apply final function
     return schema.final ? schema.final(accumulator, rowCount) : accumulator;
 }
-function getFrameBounds(frame, totalRows, currentIndex, hasOrderBy = true) {
+function getFrameBounds(frame, totalRows, currentIndex, hasOrderBy = true, orderByValues = [], equalityComparators = []) {
     if (!frame) {
         if (!hasOrderBy) {
             // No ORDER BY: default frame is entire partition (all rows)
@@ -224,9 +345,12 @@ function getFrameBounds(frame, totalRows, currentIndex, hasOrderBy = true) {
         }
         else {
             // With ORDER BY: default frame is RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
-            return { start: 0, end: currentIndex };
+            // In RANGE mode, CURRENT ROW means all peer rows (same ORDER BY values)
+            const lastPeer = findLastPeer(currentIndex, totalRows, orderByValues, equalityComparators);
+            return { start: 0, end: lastPeer };
         }
     }
+    const isRange = frame.type === 'range';
     let start;
     let end;
     // Calculate start bound
@@ -234,16 +358,27 @@ function getFrameBounds(frame, totalRows, currentIndex, hasOrderBy = true) {
         start = 0;
     }
     else if (frame.start.type === 'currentRow') {
-        start = currentIndex;
+        start = isRange
+            ? findFirstPeer(currentIndex, totalRows, orderByValues, equalityComparators)
+            : currentIndex;
     }
     else if (frame.start.type === 'preceding') {
-        // TODO: Evaluate frame.start.value expression
-        const offset = 1; // For now, hard-coded for the test
-        start = Math.max(0, currentIndex - offset);
+        const offset = getFrameOffset(frame.start.value);
+        if (isRange) {
+            start = findRangeOffsetStart(currentIndex, totalRows, orderByValues, -offset);
+        }
+        else {
+            start = Math.max(0, currentIndex - offset);
+        }
     }
     else if (frame.start.type === 'following') {
-        const offset = 1; // TODO: Evaluate frame.start.value expression
-        start = Math.min(totalRows - 1, currentIndex + offset);
+        const offset = getFrameOffset(frame.start.value);
+        if (isRange) {
+            start = findRangeOffsetStart(currentIndex, totalRows, orderByValues, offset);
+        }
+        else {
+            start = Math.min(totalRows - 1, currentIndex + offset);
+        }
     }
     else {
         start = 0;
@@ -251,50 +386,157 @@ function getFrameBounds(frame, totalRows, currentIndex, hasOrderBy = true) {
     // Calculate end bound
     if (frame.end === null) {
         // Single bound frame - end is current row
-        end = currentIndex;
+        end = isRange
+            ? findLastPeer(currentIndex, totalRows, orderByValues, equalityComparators)
+            : currentIndex;
     }
     else if (frame.end.type === 'unboundedFollowing') {
         end = totalRows - 1;
     }
     else if (frame.end.type === 'currentRow') {
-        end = currentIndex;
+        end = isRange
+            ? findLastPeer(currentIndex, totalRows, orderByValues, equalityComparators)
+            : currentIndex;
     }
     else if (frame.end.type === 'preceding') {
-        const offset = 1; // TODO: Evaluate frame.end.value expression
-        end = Math.max(0, currentIndex - offset);
+        const offset = getFrameOffset(frame.end.value);
+        if (isRange) {
+            end = findRangeOffsetEnd(currentIndex, totalRows, orderByValues, -offset);
+        }
+        else {
+            end = Math.max(0, currentIndex - offset);
+        }
     }
     else if (frame.end.type === 'following') {
-        const offset = 1; // TODO: Evaluate frame.end.value expression
-        end = Math.min(totalRows - 1, currentIndex + offset);
+        const offset = getFrameOffset(frame.end.value);
+        if (isRange) {
+            end = findRangeOffsetEnd(currentIndex, totalRows, orderByValues, offset);
+        }
+        else {
+            end = Math.min(totalRows - 1, currentIndex + offset);
+        }
     }
     else {
         end = currentIndex;
     }
+    // Empty frame when bounds invert
+    if (start > end) {
+        return { start: currentIndex + 1, end: currentIndex };
+    }
     return { start, end };
 }
-async function areRowsEqualInOrderBy(rowA, rowB, orderByCallbacks, rctx, sourceRowDescriptor) {
-    for (const callback of orderByCallbacks) {
+/** Find the first row in the peer group (rows with same ORDER BY values) */
+function findFirstPeer(currentIndex, _totalRows, orderByValues, equalityComparators) {
+    const currentVals = orderByValues[currentIndex];
+    let first = currentIndex;
+    while (first > 0 && arePeerRows(orderByValues[first - 1], currentVals, equalityComparators)) {
+        first--;
+    }
+    return first;
+}
+/** Find the last row in the peer group */
+function findLastPeer(currentIndex, totalRows, orderByValues, equalityComparators) {
+    const currentVals = orderByValues[currentIndex];
+    let last = currentIndex;
+    while (last < totalRows - 1 && arePeerRows(orderByValues[last + 1], currentVals, equalityComparators)) {
+        last++;
+    }
+    return last;
+}
+/** Check if two rows have equal ORDER BY values */
+function arePeerRows(valsA, valsB, equalityComparators) {
+    for (let i = 0; i < equalityComparators.length; i++) {
+        if (equalityComparators[i](valsA[i], valsB[i]) !== 0)
+            return false;
+    }
+    return true;
+}
+/**
+ * For RANGE N PRECEDING/FOLLOWING: find the first row whose ORDER BY value
+ * is >= (currentValue + offset). Uses the first ORDER BY expression only
+ * (SQL standard requires single ORDER BY for numeric RANGE offsets).
+ */
+function findRangeOffsetStart(currentIndex, totalRows, orderByValues, offset // negative for PRECEDING, positive for FOLLOWING
+) {
+    const currentVal = Number(orderByValues[currentIndex][0]);
+    if (!Number.isFinite(currentVal))
+        return currentIndex;
+    const targetVal = currentVal + offset;
+    // Scan from beginning to find first row >= targetVal
+    for (let i = 0; i < totalRows; i++) {
+        const rowVal = Number(orderByValues[i][0]);
+        if (Number.isFinite(rowVal) && rowVal >= targetVal) {
+            return i;
+        }
+    }
+    return totalRows; // No matching row (empty frame start)
+}
+/**
+ * For RANGE N PRECEDING/FOLLOWING: find the last row whose ORDER BY value
+ * is <= (currentValue + offset).
+ */
+function findRangeOffsetEnd(currentIndex, totalRows, orderByValues, offset) {
+    const currentVal = Number(orderByValues[currentIndex][0]);
+    if (!Number.isFinite(currentVal))
+        return currentIndex;
+    const targetVal = currentVal + offset;
+    // Scan from end to find last row <= targetVal
+    for (let i = totalRows - 1; i >= 0; i--) {
+        const rowVal = Number(orderByValues[i][0]);
+        if (Number.isFinite(rowVal) && rowVal <= targetVal) {
+            return i;
+        }
+    }
+    return -1; // No matching row (empty frame end)
+}
+function getFrameOffset(expr) {
+    // SQL grammar for frame offsets is typically an unsigned integer literal.
+    // Quereus currently supports literal numeric offsets and unary +/- on literals.
+    const value = tryExtractNumericLiteral(expr);
+    if (value === undefined) {
+        throw new QuereusError('Window frame offsets must be constant numeric literals', StatusCode.UNSUPPORTED);
+    }
+    if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+        throw new QuereusError(`Invalid window frame offset: ${value}. Must be a non-negative integer.`, StatusCode.ERROR);
+    }
+    return value;
+}
+function tryExtractNumericLiteral(expr) {
+    if (expr.type === 'literal') {
+        const v = expr.value;
+        if (typeof v === 'number')
+            return v;
+        if (typeof v === 'bigint')
+            return Number(v);
+        return undefined;
+    }
+    if (expr.type === 'unary' && (expr.operator === '+' || expr.operator === '-')) {
+        const inner = tryExtractNumericLiteral(expr.expr);
+        if (inner === undefined)
+            return undefined;
+        return expr.operator === '-' ? -inner : inner;
+    }
+    return undefined;
+}
+async function areRowsEqualInOrderBy(rowA, rowB, orderByCallbacks, rctx, sourceSlot, equalityComparators) {
+    for (let i = 0; i < orderByCallbacks.length; i++) {
+        const callback = orderByCallbacks[i];
         // Get value for row A
-        const valueA = await withAsyncRowContext(rctx, sourceRowDescriptor, () => rowA, async () => {
-            const result = callback(rctx);
-            return await Promise.resolve(result);
-        });
+        sourceSlot.set(rowA);
+        const valueA = await Promise.resolve(callback(rctx));
         // Get value for row B
-        const valueB = await withAsyncRowContext(rctx, sourceRowDescriptor, () => rowB, async () => {
-            const result = callback(rctx);
-            return await Promise.resolve(result);
-        });
-        // If any ORDER BY expression differs, rows are not equal
-        if (compareSqlValues(valueA, valueB) !== 0) {
+        sourceSlot.set(rowB);
+        const valueB = await Promise.resolve(callback(rctx));
+        // If any ORDER BY expression differs, rows are not equal (using pre-resolved typed comparator)
+        if (equalityComparators[i](valueA, valueB) !== 0) {
             return false;
         }
     }
     return true; // All ORDER BY expressions are equal
 }
-async function getOrderByKey(row, orderByCallbacks, rctx, sourceRowDescriptor) {
-    return await withAsyncRowContext(rctx, sourceRowDescriptor, () => row, async () => {
-        const values = await Promise.all(orderByCallbacks.map(callback => Promise.resolve(callback(rctx))));
-        return values.map(val => val === null ? 'NULL' : String(val)).join('|');
-    });
+async function getOrderByKey(row, orderByCallbacks, rctx, sourceSlot, keyNormalizers) {
+    sourceSlot.set(row);
+    const values = await Promise.all(orderByCallbacks.map(callback => Promise.resolve(callback(rctx))));
+    return serializeKeyNullGrouping(values, keyNormalizers);
 }
 //# sourceMappingURL=window.js.map