@svgrid/enterprise 3.0.2 → 3.1.0

package/dist/sveltekit/in-memory.js

@@ -53,6 +53,53 @@ function matches(row, plan) {
  *   - the rest ignore non-numeric / null values, and yield null for an empty
  *     numeric set (SQL returns NULL for SUM/AVG/MIN/MAX over no rows).
  */
+/**
+ * The grand-total row: every requested aggregate over the whole filtered
+ * set. Shaped like a group row (values under their column ids) so the
+ * grid renders it with the same columns.
+ */
+/**
+ * The aggregates of `rows` into `out`: one value per aggregation, or under
+ * pivot one per (pivot key path x aggregation) named `<path>_<col>`, with
+ * every pivot key path seen collected into `paths`.
+ */
+function aggregateInto(out, rows, plan, paths) {
+    if (plan.pivotBy?.length) {
+        const cells = new Map();
+        for (const r of rows) {
+            const path = plan.pivotBy.map((p) => asString(r[p])).join('_');
+            const cell = cells.get(path);
+            if (cell)
+                cell.push(r);
+            else
+                cells.set(path, [r]);
+        }
+        for (const [path, cellRows] of cells) {
+            paths?.add(path);
+            for (const agg of plan.aggregations ?? []) {
+                out[`${path}_${agg.field}`] = aggregate(cellRows, agg.field, agg.fn);
+            }
+        }
+    }
+    // The plain aggregate, on its own or beside the per-key fields of a pivot,
+    // where it is the row total.
+    for (const agg of plan.aggregations ?? [])
+        out[agg.field] = aggregate(rows, agg.field, agg.fn);
+}
+function grandTotalOf(all, plan, expression) {
+    // The group path is the trailing `pathPredicates` entries of `where`; it
+    // scopes this request, not the total, so it comes off.
+    const filtersOnly = {
+        ...plan,
+        where: plan.where.slice(0, plan.where.length - (plan.pathPredicates ?? 0)),
+    };
+    let rows = all.filter((r) => matches(r, filtersOnly));
+    if (expression)
+        rows = rows.filter(expression);
+    const out = {};
+    aggregateInto(out, rows, plan);
+    return out;
+}
 function aggregate(rows, field, fn) {
     if (fn === 'count')
         return rows.length;
@@ -112,6 +159,7 @@ export function createInMemoryDataSource(initial, schema) {
             // grid then tells the user the filter did not run rather than showing a
             // superset that looks filtered.
             let appliedExpression = false;
+            let expressionPredicate = null;
             if (plan.expression) {
                 const predicate = compilePredicate(plan.expression, {
                     getValue: (row, columnId) => row[columnId],
@@ -119,9 +167,16 @@ export function createInMemoryDataSource(initial, schema) {
                 });
                 if (predicate) {
                     filtered = filtered.filter(predicate);
+                    expressionPredicate = predicate;
                     appliedExpression = true;
                 }
             }
+            // The grand total spans everything the FILTERS admit - the whole
+            // store minus the filters and the expression, but NOT minus the group
+            // path, which only scopes this request.
+            const grandTotal = plan.grandTotal
+                ? { grandTotal: grandTotalOf(store, plan, expressionPredicate) }
+                : {};
             // Grouped request: return one row per distinct key at this level, each
             // carrying the requested aggregates. The chosen path is already in
             // `plan.where`, so `filtered` is exactly this group's slice of the data.
@@ -138,18 +193,38 @@ export function createInMemoryDataSource(initial, schema) {
                     else
                         buckets.set(key, [row]);
                 }
+                // Pivoting: every aggregate is computed once per distinct pivot key
+                // path inside the group, under a field named from the path, and the
+                // field list goes back so the grid can build the columns.
+                const pivotPaths = new Set();
                 const groups = [...buckets.entries()].map(([key, rows]) => {
                     const out = { [groupField]: key };
-                    for (const agg of plan.aggregations ?? []) {
-                        out[agg.field] = aggregate(rows, agg.field, agg.fn);
-                    }
+                    aggregateInto(out, rows, plan, pivotPaths);
+                    // What opening this group would show: distinct keys of the next
+                    // level, or the rows themselves at the innermost group level.
+                    out.childCount = plan.childGroupBy
+                        ? new Set(rows.map((r) => asString(r[plan.childGroupBy]))).size
+                        : rows.length;
                     return out;
                 });
+                // The pivoted fields in a fixed order - key paths in plain string
+                // order, aggregations as requested under each - so the grid builds
+                // the same columns whatever order the groups came in. Every group
+                // row carries every field; a cell with no rows under it is null, the
+                // way a conditional aggregate answers in SQL.
+                const pivotFields = [...pivotPaths]
+                    .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
+                    .flatMap((path) => (plan.aggregations ?? []).map((agg) => `${path}_${agg.field}`));
+                for (const g of groups) {
+                    for (const f of pivotFields)
+                        if (!(f in g))
+                            g[f] = null;
+                }
                 // Sort by the group key unless the request sorted on a column we
                 // actually produced (the key or an aggregate).
                 const produced = new Set([
                     groupField,
-                    ...(plan.aggregations ?? []).map((a) => a.field),
+                    ...(plan.pivotBy?.length ? [] : (plan.aggregations ?? []).map((a) => a.field)),
                 ]);
                 const groupOrder = plan.orderBy.filter((o) => produced.has(o.field));
                 const sorted = groupOrder.length
@@ -161,6 +236,8 @@ export function createInMemoryDataSource(initial, schema) {
                     // its scrollbar and paging from this.
                     rowCount: sorted.length,
                     appliedExpression,
+                    ...grandTotal,
+                    ...(plan.pivotBy?.length ? { pivotResultFields: pivotFields } : {}),
                 };
             }
             const sortedLeaves = sortRows(filtered, plan.orderBy);
@@ -168,6 +245,7 @@ export function createInMemoryDataSource(initial, schema) {
                 rows: sortedLeaves.slice(plan.offset, plan.offset + plan.limit),
                 rowCount: sortedLeaves.length,
                 appliedExpression,
+                ...grandTotal,
             };
         },
         async createRow(input) {
@@ -191,6 +269,49 @@ export function createInMemoryDataSource(initial, schema) {
         async deleteRow(id) {
             store = store.filter((r) => asString(r[idField]) !== id);
         },
+        /**
+         * The reference for a bulk edit by RULE: every row the filters admit
+         * that the selection rule says is selected, patched in place. The rule
+         * is resolved by walking group values the way the grid builds routes,
+         * so the nested shape works without the grid having sent any rows.
+         */
+        async updateWhere(filterModel, patch, selection) {
+            const plan = planQuery(schema, {
+                startRow: 0, endRow: 0, pageIndex: 0, pageSize: 0, sortModel: [], filterModel,
+            });
+            // Which columns the nested rule is keyed by, level by level, comes
+            // from the request that built it; a flat rule needs none. Callers
+            // pass the groupBy through `filterModel.expression`-free means: the
+            // rule itself carries `groupBy` when it is nested.
+            const groupBy = selection.groupBy ?? [];
+            const selected = (row) => {
+                if ('selectAll' in selection) {
+                    const id = asString(row[idField]);
+                    return selection.selectAll !== selection.toggled.includes(id);
+                }
+                // Walk the tree: each level's key is the row's value in that group
+                // column; the leaf is the row id.
+                let node = selection;
+                let state = selection.selectAllChildren;
+                const keys = [...groupBy.map((g) => asString(row[g])), asString(row[idField])];
+                for (const key of keys) {
+                    const next = node.toggled[key];
+                    if (!next)
+                        return state;
+                    node = next;
+                    state = next.selectAllChildren;
+                }
+                return state;
+            };
+            let changed = 0;
+            store = store.map((row) => {
+                if (!matches(row, plan) || !selected(row))
+                    return row;
+                changed += 1;
+                return { ...row, ...patch };
+            });
+            return changed;
+        },
         async getAggregate(request) {
             // Apply the (optional) filter using the same plan machinery as getRows,
             // over the whole store (no paging), then reduce in memory.

package/dist/sveltekit/index.d.ts

@@ -1,4 +1,4 @@
-export { planQuery, coerce, type QueryPlan, type PlanPredicate, type PlanOp, } from './query-plan.js';
+export { planQuery, coerce, BUILTIN_AGGREGATORS, type QueryPlan, type PlanPredicate, type PlanOp, type PlanAggregate, type PlanOptions, } from './query-plan.js';
 export { createInMemoryDataSource } from './in-memory.js';
 export { createKitDataSource, createKitHandlers, type KitDataSourceOptions, type KitHandlerOptions, type KitScope, type KitHandlers, type KitMessage, } from './transport.js';
 export { planToSql, type SqlDialect, type SqlPlan } from './sql.js';

package/dist/sveltekit/index.js

@@ -1,4 +1,4 @@
-export { planQuery, coerce, } from './query-plan.js';
+export { planQuery, coerce, BUILTIN_AGGREGATORS, } from './query-plan.js';
 export { createInMemoryDataSource } from './in-memory.js';
 export { createKitDataSource, createKitHandlers, } from './transport.js';
 export { planToSql } from './sql.js';

package/dist/sveltekit/query-plan.d.ts

@@ -24,10 +24,25 @@ export type PlanPredicate = {
     /** Operands for `in` (set / facet filter). */
     values?: unknown[];
 };
-/** An aggregate to compute per group. */
+/**
+ * An aggregate to compute per group. `fn` is one of the built-ins or a
+ * name the planner was told to allow (`PlanOptions.aggregators`); it is
+ * never a string the client chose on its own, because it ends up in SQL.
+ */
 export type PlanAggregate = {
     field: string;
-    fn: 'sum' | 'avg' | 'min' | 'max' | 'count';
+    fn: string;
+};
+/** What the planner emits without being asked. */
+export declare const BUILTIN_AGGREGATORS: ReadonlyArray<string>;
+export type PlanOptions = {
+    /**
+     * Aggregate function names to allow besides the built-ins, exactly as
+     * the database spells them (`median`, `percentile_cont`, `count_distinct`).
+     * Anything a request asks for that is not built in or listed here is
+     * dropped from the plan.
+     */
+    aggregators?: ReadonlyArray<string>;
 };
 export type QueryPlan = {
     /** AND-combined column predicates. */
@@ -56,8 +71,39 @@ export type QueryPlan = {
      * grouping existed) stays valid; `planQuery` always sets it.
      */
     groupBy?: string | null;
-    /** Aggregates to compute alongside `groupBy`. Empty/absent for a leaf query. */
+    /**
+     * Aggregates to compute alongside `groupBy`. Empty for a leaf query,
+     * unless `grandTotal` is set - then they are what the total is made of.
+     */
     aggregations?: PlanAggregate[];
+    /**
+     * On a grouped query, also count what the NEXT level holds per group -
+     * the distinct keys of `childGroupBy`, or the raw rows when this is the
+     * innermost group level. Lands on each group row as `childCount`, which
+     * the grid shows beside the key and uses to size the group before it
+     * opens. Always set on a grouped plan from `planQuery`.
+     */
+    childGroupBy?: string | null;
+    /**
+     * How many entries at the END of `where` are the group path (`groupKeys`
+     * turned into equality predicates) rather than filters the user set.
+     * The grand total aggregates over the filters alone, so it drops these.
+     */
+    pathPredicates?: number;
+    /**
+     * Server-side pivot, on a grouped plan: the columns whose distinct values
+     * become fields. Each group row then carries, for every (pivot key path x
+     * aggregation), a field named `<key>[_<key>]_<col>` - `2024_amount` - and
+     * the response lists them in `pivotResultFields`. Absent when not
+     * pivoting. The separator is `_`, matching the row model's default.
+     */
+    pivotBy?: string[];
+    /**
+     * The grid wants a grand-total row and does not have one cached. Compute
+     * the aggregates over the whole filtered set (the request's filters,
+     * without the group path) and answer with `ServerResult.grandTotal`.
+     */
+    grandTotal?: boolean;
     /**
      * The advanced-filter expression, present ONLY when every column it
      * references is on the schema.
@@ -72,4 +118,4 @@ export type QueryPlan = {
 };
 /** Coerce a raw string request value to the field's runtime type for correct comparisons. */
 export declare function coerce(type: EntityFieldType, raw: unknown): unknown;
-export declare function planQuery<TData extends RowData>(schema: EntitySchema<TData>, request: ServerRequest): QueryPlan;
+export declare function planQuery<TData extends RowData>(schema: EntitySchema<TData>, request: ServerRequest, options?: PlanOptions): QueryPlan;

package/dist/sveltekit/query-plan.js

@@ -1,3 +1,7 @@
+/** What the planner emits without being asked. */
+export const BUILTIN_AGGREGATORS = ['sum', 'avg', 'min', 'max', 'count'];
+/** Function names are identifiers, nothing else, before they reach SQL. */
+const AGG_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
 /** Grid filter operator -> normalized plan operator. Unmapped operators are ignored. */
 const OP_MAP = {
     equals: 'eq',
@@ -26,8 +30,12 @@ export function coerce(type, raw) {
             return typeof raw === 'string' ? raw : String(raw);
     }
 }
-export function planQuery(schema, request) {
+export function planQuery(schema, request, options = {}) {
     const fields = new Map(schema.fields.map((f) => [f.field, f]));
+    const allowedFn = new Set([
+        ...BUILTIN_AGGREGATORS,
+        ...(options.aggregators ?? []).filter((name) => AGG_NAME.test(name)),
+    ]);
     const where = [];
     const fm = request.filterModel ?? {};
     for (const [field, spec] of Object.entries(fm.columns ?? {})) {
@@ -86,9 +94,13 @@ export function planQuery(schema, request) {
     }
     // Above the innermost level the grid wants GROUP rows; at or below it, leaves.
     const groupBy = groupKeys.length < groupCols.length ? (groupCols[groupKeys.length] ?? null) : null;
-    const aggregations = groupBy
+    // Aggregates ride along on a grouped plan, and on a leaf plan ONLY when a
+    // grand total was asked for - the leaf query itself never uses them, but
+    // the total statement does.
+    const aggregations = groupBy || request.needsGrandTotal
         ? (request.aggregations ?? [])
-            .filter((a) => fields.has(a.col))
+            // Column AND function are whitelisted: both end up in SQL.
+            .filter((a) => fields.has(a.col) && allowedFn.has(a.fn))
             .map((a) => ({ field: a.col, fn: a.fn }))
         : [];
     // ---- Advanced filter ---------------------------------------------------
@@ -96,6 +108,10 @@ export function planQuery(schema, request) {
     // schema the whole expression is dropped. Keeping the understood parts would
     // silently widen the result set.
     const expression = admitExpression(request.filterModel?.expression, fields);
+    // What the level below this one groups by, so a group row can say how
+    // many children it has. Null at the innermost group level (children are
+    // leaves) and on a leaf query.
+    const childGroupBy = groupBy ? (groupCols[groupKeys.length + 1] ?? null) : null;
     return {
         where,
         search,
@@ -104,6 +120,12 @@ export function planQuery(schema, request) {
         offset: request.startRow,
         groupBy,
         aggregations,
+        ...(groupBy ? { childGroupBy } : {}),
+        ...(groupBy && request.pivotMode && request.pivotBy?.length
+            ? { pivotBy: request.pivotBy.filter((f) => fields.has(f)) }
+            : {}),
+        pathPredicates: Math.min(groupKeys.length, groupCols.length),
+        ...(request.needsGrandTotal ? { grandTotal: true } : {}),
         ...(expression ? { expression } : {}),
     };
 }

package/dist/sveltekit/sql-source.d.ts

@@ -43,5 +43,11 @@ export type SqlDataSourceConfig<TData extends RowData> = {
      * Default true.
      */
     returning?: boolean;
+    /**
+     * Aggregate function names to accept from a request besides `sum`,
+     * `avg`, `min`, `max` and `count`, spelt as the database spells them.
+     * Names outside this list never reach SQL.
+     */
+    aggregators?: ReadonlyArray<string>;
 };
 export declare function createSqlDataSource<TData extends RowData>(config: SqlDataSourceConfig<TData>): WritableDataSource<TData> & AggregateSource;

package/dist/sveltekit/sql-source.js

@@ -1,5 +1,5 @@
 import { resolveIdField } from '../schema.js';
-import { nudgeEnterprise } from '../license.js';
+import { nudgeEnterpriseFor } from '../license.js';
 import { planQuery } from './query-plan.js';
 import { planToSql } from './sql.js';
 const SQL_AGG = { sum: 'SUM', avg: 'AVG', min: 'MIN', max: 'MAX' };
@@ -19,10 +19,11 @@ function binder(dialect, params) {
 }
 const squish = (sql) => sql.replace(/\s+/g, ' ').trim();
 export function createSqlDataSource(config) {
-    nudgeEnterprise('Studio'); // soft-gate; never blocks, safe on the server
+    nudgeEnterpriseFor('studio', 'Studio'); // evaluation nudge; never blocks, safe on the server
     const { schema, execute } = config;
     const dialect = config.dialect ?? {};
     const returning = config.returning ?? true;
+    const planOptions = { aggregators: config.aggregators ?? [] };
     const id = quoter(dialect);
     const idField = resolveIdField(schema);
     // Optionally schema-qualify the table: "schema"."table" (each part quoted separately).
@@ -41,15 +42,42 @@ export function createSqlDataSource(config) {
     const RET = returning ? ` RETURNING ${projection}` : '';
     return {
         async getRows(request) {
-            const plan = planQuery(schema, request);
+            const plan = planQuery(schema, request, planOptions);
             const sql = planToSql(plan, planDialect);
             const t = qtable;
-            const rowsSql = squish(`SELECT ${projection} FROM ${t} ${sql.whereText} ${sql.orderByText} LIMIT ${sql.limit} OFFSET ${sql.offset}`);
-            const countSql = squish(`SELECT COUNT(*) AS count FROM ${t} ${sql.whereText}`);
+            // A grouped level selects the group column + aggregates and groups by
+            // it; a leaf level selects the projection. `countText` already knows
+            // that a grouped total is the number of DISTINCT keys, not of rows.
+            // Pivot: the distinct key paths first, then one conditional aggregate
+            // per (path x aggregation) in the grouped SELECT.
+            let select = sql.select;
+            let grandTotalSelect = sql.grandTotalSelect;
+            let pivotResultFields;
+            if (plan.groupBy && plan.pivotBy?.length) {
+                const keyRows = await execute(squish(`SELECT ${sql.pivotKeysSelect} FROM ${t} ${sql.whereText}`), sql.params);
+                const pivot = sql.pivotSelect(keyRows);
+                select = pivot.select;
+                if (plan.grandTotal)
+                    grandTotalSelect = pivot.grandTotalSelect;
+                pivotResultFields = pivot.fields;
+            }
+            const rowsSql = plan.groupBy
+                ? squish(`SELECT ${select} FROM ${t} ${sql.whereText} ${sql.groupByText} ${sql.orderByText} LIMIT ${sql.limit} OFFSET ${sql.offset}`)
+                : squish(`SELECT ${projection} FROM ${t} ${sql.whereText} ${sql.orderByText} LIMIT ${sql.limit} OFFSET ${sql.offset}`);
+            const countSql = squish(`SELECT ${sql.countText} AS count FROM ${t} ${sql.whereText}`);
             const rows = await execute(rowsSql, sql.params);
             const countRows = await execute(countSql, sql.params);
             const rowCount = Number(countRows[0]?.count ?? rows.length);
-            return { rows: rows, rowCount };
+            const result = { rows: rows, rowCount };
+            if (pivotResultFields)
+                result.pivotResultFields = pivotResultFields;
+            // The grand total is its own statement, over the filters without the
+            // group path - planToSql hands back exactly those pieces.
+            if (plan.grandTotal && grandTotalSelect) {
+                const totalRows = await execute(squish(`SELECT ${grandTotalSelect} FROM ${t} ${sql.grandTotalWhereText}`), sql.grandTotalParams);
+                result.grandTotal = (totalRows[0] ?? null);
+            }
+            return result;
         },
         async createRow(input) {
             const cols = Object.keys(input);

package/dist/sveltekit/sql.d.ts

@@ -64,5 +64,36 @@ export type SqlPlan = {
      * grid's scrollbar and paging will be sized from the wrong number.
      */
     countText: string;
+    /**
+     * The grand-total statement's pieces, present only when the request asked
+     * for one (`plan.grandTotal`): a SELECT list of every aggregate over the
+     * whole filtered set (aliased like `select`), and a WHERE + params of the
+     * filters WITHOUT the group path. Run it as its own query:
+     *
+     *     SELECT ${sql.grandTotalSelect} FROM sales ${sql.grandTotalWhereText}
+     *
+     * All three are empty when no total was asked for.
+     */
+    grandTotalSelect: string;
+    grandTotalWhereText: string;
+    grandTotalParams: unknown[];
+    /**
+     * Server-side pivot needs two statements, because SQL cannot make
+     * columns out of values it has not seen yet. First fetch the distinct
+     * key paths: `SELECT ${sql.pivotKeysSelect} FROM t ${sql.whereText}`
+     * (one row per path, columns named after the pivot columns). Then build
+     * the grouped SELECT with `pivotSelect(keyRows)`: one conditional
+     * aggregate per (key path x aggregation), aliased `<key>_<col>` - the
+     * fields the grid expects in `pivotResultFields` (returned alongside).
+     * Key values are inlined as quoted literals; they came from the database
+     * itself. Both are empty when not pivoting.
+     */
+    pivotKeysSelect: string;
+    pivotSelect: (keyRows: ReadonlyArray<Record<string, unknown>>) => {
+        select: string;
+        fields: string[];
+        /** The same aggregates for the grand-total statement, no group column. */
+        grandTotalSelect: string;
+    };
 };
 export declare function planToSql(plan: QueryPlan, dialect?: SqlDialect): SqlPlan;

package/dist/sveltekit/sql.js

@@ -2,37 +2,66 @@ export function planToSql(plan, dialect = {}) {
     const q = dialect.quote ?? '"';
     const useIlike = dialect.ilike ?? false;
     const params = [];
-    const ph = () => {
-        if (dialect.placeholders === '$')
-            return `$${params.length}`;
-        if (dialect.placeholders === '@')
-            return `@p${params.length}`;
-        return '?';
-    };
-    const bind = (v) => {
-        params.push(v);
-        return ph();
-    };
     const columnFor = dialect.column ?? ((f) => f);
     const id = (field) => {
         const c = columnFor(field);
         return `${q}${c.replace(new RegExp(q, 'g'), q + q)}${q}`;
     };
-    const like = (field, pattern) => {
-        const p = bind(pattern);
-        return useIlike ? `${id(field)} ILIKE ${p}` : `LOWER(${id(field)}) LIKE LOWER(${p})`;
+    // The planner whitelists function names; this is the second lock on the
+    // same door, since an aggregate name is pasted into the statement raw.
+    const aggName = (fn) => {
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(fn))
+            throw new Error(`planToSql: "${fn}" is not an aggregate function name`);
+        return fn.toUpperCase();
     };
-    const clauses = [];
-    for (const pred of plan.where) {
-        clauses.push(predicateSql(pred, { id, bind, like }));
-    }
-    if (plan.search && plan.search.fields.length > 0) {
-        const term = `%${plan.search.term}%`;
-        const ors = plan.search.fields.map((f) => like(f, term));
-        clauses.push(`(${ors.join(' OR ')})`);
+    /**
+     * Render predicates + search into one WHERE body, binding into `into`.
+     * Placeholder numbering follows that array, so a second call with a fresh
+     * array (the grand total) starts from $1 again.
+     */
+    const buildWhere = (preds, into) => {
+        const ph = () => {
+            if (dialect.placeholders === '$')
+                return `$${into.length}`;
+            if (dialect.placeholders === '@')
+                return `@p${into.length}`;
+            return '?';
+        };
+        const bind = (v) => {
+            into.push(v);
+            return ph();
+        };
+        const like = (field, pattern) => {
+            const p = bind(pattern);
+            return useIlike ? `${id(field)} ILIKE ${p}` : `LOWER(${id(field)}) LIKE LOWER(${p})`;
+        };
+        const clauses = [];
+        for (const pred of preds)
+            clauses.push(predicateSql(pred, { id, bind, like }));
+        if (plan.search && plan.search.fields.length > 0) {
+            const term = `%${plan.search.term}%`;
+            const ors = plan.search.fields.map((f) => like(f, term));
+            clauses.push(`(${ors.join(' OR ')})`);
+        }
+        return clauses.join(' AND ');
+    };
+    const where = buildWhere(plan.where, params);
+    // A grouped level can only order by what it produces - the key and the
+    // aggregates (under pivot only the key, the aggregates being split per
+    // pivot key); a leaf column there is a SQL error. With nothing left the
+    // key orders the groups, so paging over them is deterministic. Same rule
+    // as the in-memory reference.
+    let order = plan.orderBy;
+    if (plan.groupBy) {
+        const produced = new Set([
+            plan.groupBy,
+            ...(plan.pivotBy?.length ? [] : (plan.aggregations ?? []).map((a) => a.field)),
+        ]);
+        order = order.filter((o) => produced.has(o.field));
+        if (order.length === 0)
+            order = [{ field: plan.groupBy, desc: false }];
     }
-    const where = clauses.join(' AND ');
-    const orderBy = plan.orderBy.map((o) => `${id(o.field)} ${o.desc ? 'DESC' : 'ASC'}`).join(', ');
+    const orderBy = order.map((o) => `${id(o.field)} ${o.desc ? 'DESC' : 'ASC'}`).join(', ');
     // ---- Grouping ----------------------------------------------------------
     // `plan.groupBy` is a single column: the grid asks one level at a time and
     // sends the chosen path as ordinary predicates, so there is never a
@@ -44,13 +73,89 @@ export function planToSql(plan, dialect = {}) {
         for (const agg of plan.aggregations ?? []) {
             // COUNT(*) rather than COUNT(col) so the tally counts rows in the group
             // rather than non-null values of one column.
-            const expr = agg.fn === 'count' ? 'COUNT(*)' : `${agg.fn.toUpperCase()}(${id(agg.field)})`;
+            const expr = agg.fn === 'count' ? 'COUNT(*)' : `${aggName(agg.fn)}(${id(agg.field)})`;
             // Aliased back to the source column name: that is the key the grid reads
             // the aggregate from on the group row.
             parts.push(`${expr} AS ${id(agg.field)}`);
         }
+        // What opening the group would show, for the badge beside its key: the
+        // distinct keys of the next level, or the rows when this is the innermost
+        // group level. Always emitted; a caller that does not want the extra
+        // aggregate can drop the alias from the list.
+        parts.push(plan.childGroupBy
+            ? `COUNT(DISTINCT ${id(plan.childGroupBy)}) AS ${id('childCount')}`
+            : `COUNT(*) AS ${id('childCount')}`);
         select = parts.join(', ');
     }
+    // The grand total aggregates over everything the FILTERS admit, so the
+    // group path (the trailing `pathPredicates` entries of `where`, per
+    // planQuery) is left out.
+    let grandTotalSelect = '';
+    let grandTotalWhereText = '';
+    const grandTotalParams = [];
+    if (plan.grandTotal) {
+        grandTotalSelect = (plan.aggregations ?? [])
+            .map((agg) => {
+            const expr = agg.fn === 'count' ? 'COUNT(*)' : `${aggName(agg.fn)}(${id(agg.field)})`;
+            return `${expr} AS ${id(agg.field)}`;
+        })
+            .join(', ');
+        const filtersOnly = plan.where.slice(0, plan.where.length - (plan.pathPredicates ?? 0));
+        const body = buildWhere(filtersOnly, grandTotalParams);
+        grandTotalWhereText = body ? `WHERE ${body}` : '';
+    }
+    // ---- Pivot ------------------------------------------------------------
+    let pivotKeysSelect = '';
+    let pivotSelect = () => ({ select: '', fields: [], grandTotalSelect: '' });
+    if (plan.groupBy && plan.pivotBy?.length) {
+        const pivotCols = plan.pivotBy;
+        const keyList = pivotCols
+            .map((c) => (columnFor(c) === c ? id(c) : `${id(c)} AS ${q}${c}${q}`))
+            .join(', ');
+        pivotKeysSelect = `DISTINCT ${keyList}`;
+        pivotSelect = (keyRows) => {
+            // Key paths in plain string order, so the field list (and the
+            // columns the grid builds from it) is the same whatever order the
+            // distinct-keys query returned - and the same as the reference.
+            const pathOf = (row) => pivotCols.map((c) => String(row[c] ?? '')).join('_');
+            keyRows = [...keyRows].sort((a, b) => {
+                const x = pathOf(a);
+                const y = pathOf(b);
+                return x < y ? -1 : x > y ? 1 : 0;
+            });
+            const groupCol = id(plan.groupBy);
+            const parts = [groupCol];
+            const totals = [];
+            const fields = [];
+            for (const keyRow of keyRows) {
+                const path = pivotCols.map((c) => String(keyRow[c] ?? ''));
+                // The key path as an inline condition. Values are quoted as string
+                // literals with doubled quotes; a caller with typed columns can
+                // rewrite through `pivotSelect` itself.
+                const cond = pivotCols
+                    .map((c, i) => `${id(c)} = '${path[i].replace(/'/g, "''")}'`)
+                    .join(' AND ');
+                for (const agg of plan.aggregations ?? []) {
+                    const field = `${path.join('_')}_${agg.field}`;
+                    const inner = agg.fn === 'count' ? '1' : id(agg.field);
+                    const fn = agg.fn === 'count' ? 'COUNT' : aggName(agg.fn);
+                    const expr = `${fn}(CASE WHEN ${cond} THEN ${inner} END) AS ${id(field)}`;
+                    parts.push(expr);
+                    totals.push(expr);
+                    fields.push(field);
+                }
+            }
+            // The plain aggregates too: the row total beside the per-key cells,
+            // which is what a Total column group reads.
+            for (const agg of plan.aggregations ?? []) {
+                const expr = agg.fn === 'count' ? 'COUNT(*)' : `${aggName(agg.fn)}(${id(agg.field)})`;
+                parts.push(`${expr} AS ${id(agg.field)}`);
+                totals.push(`${expr} AS ${id(agg.field)}`);
+            }
+            parts.push(`COUNT(*) AS ${id('childCount')}`);
+            return { select: parts.join(', '), fields, grandTotalSelect: totals.join(', ') };
+        };
+    }
     // A grouped total is the number of distinct keys, not of underlying rows.
     const countText = plan.groupBy
         ? `COUNT(DISTINCT ${id(plan.groupBy)})`
@@ -67,6 +172,11 @@ export function planToSql(plan, dialect = {}) {
         groupBy,
         groupByText: groupBy ? `GROUP BY ${groupBy}` : '',
         countText,
+        grandTotalSelect,
+        grandTotalWhereText,
+        grandTotalParams,
+        pivotKeysSelect,
+        pivotSelect,
     };
 }
 function predicateSql(pred, ctx) {