Simple Aggregate Function Test

1import { describe, expect, it } from "vitest";
2import { query } from "./clickhouse.js";
3import { readArray } from "../src/readers/composite.js";
4import { NeedMoreData, Cursor } from "../src/readers/core.js";
5import { readUInt64, readUInt8 } from "../src/readers/integers.js";
6import { readSimpleAggregateFunction } from "../src/readers/simpleAggregateFunction.js";
7
8async function reader(expr: string): Promise<Cursor> {
9  return new Cursor(await query(`SELECT ${expr} FORMAT RowBinary`));
10}
11
12/**
13 * `SimpleAggregateFunction(func, T)` is TRANSPARENT in RowBinary: the column
14 * already holds a finished value of the underlying type `T` (the partial
15 * aggregate of a "simple" function — sum, min, max, groupArrayArray, ... — is
16 * just a value of `T`), so it is encoded byte-for-byte the same as `T`. There
17 * is no dedicated reader: decode the inner `T` directly.
18 *
19 * Do NOT confuse it with `AggregateFunction(func, T)`, whose value is an opaque
20 * serialized aggregation STATE with a function-specific binary layout.
21 */
22describe("SimpleAggregateFunction (transparent — decode as the inner type)", () => {
23  it("SimpleAggregateFunction(sum, UInt64) decodes exactly like UInt64", async () => {
24    const r = await reader("CAST(42 AS SimpleAggregateFunction(sum, UInt64))");
25    // readSimpleAggregateFunction is the identity combinator: just readUInt64.
26    expect(readSimpleAggregateFunction(readUInt64)(r)).toBe(42n); // identical bytes to UInt64 42: 2a 00 00 00 00 00 00 00
27    expect(r.pos).toBe(8);
28  });
29
30  it("SimpleAggregateFunction(groupArrayArray, Array(UInt8)) is just Array(UInt8)", async () => {
31    const r = await reader(
32      "CAST([1, 2, 3] AS SimpleAggregateFunction(groupArrayArray, Array(UInt8)))",
33    );
34    expect(readArray(readUInt8)(r)).toEqual([1, 2, 3]); // varint len 03, then bytes
35    expect(r.pos).toBe(4);
36  });
37
38  describe("advance() edge cases", () => {
39    it("throws NeedMoreData for every incomplete prefix (0 .. full.length-1)", async () => {
40      const full = await query(
41        "SELECT CAST(42 AS SimpleAggregateFunction(sum, UInt64)) FORMAT RowBinary",
42      );
43      for (let len = 0; len < full.length; len++) {
44        const r = new Cursor(full.subarray(0, len));
45        let thrown: unknown;
46        try {
47          readUInt64(r);
48        } catch (e) {
49          thrown = e;
50        }
51        expect(thrown, `prefix length ${len} of ${full.length}`).toBe(
52          NeedMoreData,
53        );
54      }
55    });
56  });
57});