test(service-analytics): a duration sum's empty-group 0 is answered in the statement, and the all-NULL group sorts and pages as it

Main now answers a measure's empty-group identity in the native statement
(COALESCE) instead of folding it after the rows come back, and orders with
NULLS LAST. The duration measure's statement takes the same wrap, so:

- the exact-SQL cases expect COALESCE(SUM(...), 0) on the filtered sum;
- the presentation case's client hands back the statement's 0;
- the live ordering case no longer leaves out group c (no record carrying
  both columns): ascending it pages as b (-3599.25), c (0), a (91800) on
  SQLite and PostgreSQL alike.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AKPixnkg91qCkQCVFDJuqW

Author: claude

packages/services/service-analytics/src/__tests__/dataset-duration-measure.test.ts

@@ -264,21 +264,29 @@ for (const cell of CELLS) {
         const total = await services.native!.queryDataset(DATASET, { measures: ['avg_hours', 'total_seconds'] } as any);
         expect(total.rows).toEqual([{ avg_hours: aggregate(ROWS, 'avg', 'hours'), total_seconds: aggregate(ROWS, 'sum', 'seconds') }]);
 
-        // Group `c` is left out: its sum is SQL NULL until the strategy folds it
-        // to 0, and the dialects order a NULL at opposite ends.
-        const run = await counted(() =>
-          services.native!.queryDataset(DATASET, {
-            measures: ['total_seconds'],
-            dimensions: ['category'],
-            runtimeFilter: { category: { $ne: 'c' } },
-            order: { total_seconds: 'asc' },
-            limit: 1,
-          } as any),
-        );
-        expect(run.error, run.error?.message).toBeUndefined();
-        expect(run.rawSql).toBe(1);
+        // [#25907] Group `c` has no record carrying both columns. Its sum is
+        // answered as 0 in the statement, so it sorts and pages as 0 on both
+        // dialects: ascending it is b (-3599.25), c (0), a (91800). Folded after
+        // the rows came back, SQLite ordered the NULL first and PostgreSQL last.
+        const page = (offset: number) =>
+          counted(() =>
+            services.native!.queryDataset(DATASET, {
+              measures: ['total_seconds'],
+              dimensions: ['category'],
+              order: { total_seconds: 'asc' },
+              limit: 1,
+              offset,
+            } as any),
+          );
+        const first = await page(0);
+        expect(first.error, first.error?.message).toBeUndefined();
+        expect(first.rawSql).toBe(1);
         expect(reads.statements[reads.statements.length - 1]).toContain('ORDER BY "total_seconds" ASC');
-        expect(run.value!.rows).toEqual([{ category: 'b', total_seconds: -3599.25 }]);
+        expect(reads.statements[reads.statements.length - 1]).toContain('COALESCE(SUM(');
+        expect(first.value!.rows).toEqual([{ category: 'b', total_seconds: -3599.25 }]);
+        const second = await page(1);
+        expect(second.error, second.error?.message).toBeUndefined();
+        expect(second.value!.rows).toEqual([{ category: 'c', total_seconds: 0 }]);
       });
 
       it('the cube door serves the registered dataset by name, with the same numbers', async () => {

packages/services/service-analytics/src/__tests__/native-sql-duration-measure.test.ts

@@ -68,19 +68,21 @@ describe('[#25778] NativeSQLStrategy — the duration measure as a statement', (
     [
       'sqlite',
       'AVG(((ROUND((julianday(resolved_at) - julianday(opened_at)) * 86400000.0) / 1000.0) / 3600.0)) AS "avg_hours"',
-      'SUM(CASE WHEN priority = $1 THEN (ROUND((julianday(resolved_at) - julianday(opened_at)) * 86400000.0) / 1000.0) END) AS "total_seconds"',
+      'COALESCE(SUM(CASE WHEN priority = $1 THEN (ROUND((julianday(resolved_at) - julianday(opened_at)) * 86400000.0) / 1000.0) END), 0) AS "total_seconds"',
     ],
     [
       'postgres',
       'AVG((CAST(EXTRACT(EPOCH FROM (resolved_at - opened_at)) AS DOUBLE PRECISION) / 3600.0)) AS "avg_hours"',
-      'SUM(CASE WHEN priority = $1 THEN CAST(EXTRACT(EPOCH FROM (resolved_at - opened_at)) AS DOUBLE PRECISION) END) AS "total_seconds"',
+      'COALESCE(SUM(CASE WHEN priority = $1 THEN CAST(EXTRACT(EPOCH FROM (resolved_at - opened_at)) AS DOUBLE PRECISION) END), 0) AS "total_seconds"',
     ],
     [
       'mysql',
       'AVG(((TIMESTAMPDIFF(MICROSECOND, opened_at, resolved_at) / 1.0E6) / 3600.0)) AS "avg_hours"',
-      'SUM(CASE WHEN priority = $1 THEN (TIMESTAMPDIFF(MICROSECOND, opened_at, resolved_at) / 1.0E6) END) AS "total_seconds"',
+      'COALESCE(SUM(CASE WHEN priority = $1 THEN (TIMESTAMPDIFF(MICROSECOND, opened_at, resolved_at) / 1.0E6) END), 0) AS "total_seconds"',
     ],
   ])('%s: the per-dialect difference, divided by the unit, under the aggregate and its measure filter', async (dialect, avg, filteredSum) => {
+    // [#25907] The `sum` answers its empty-group identity `0` in the statement,
+    // where the order and the window read it; the `avg` has none and keeps NULL.
     const { sql, params } = await native.generateSql(q(), nativeCtx({ dialect }));
     expect(sql).toBe(`SELECT category AS "category", ${avg}, ${filteredSum} FROM "${OBJECT}" GROUP BY category`);
     expect(params).toEqual(['high']);
@@ -110,10 +112,12 @@ describe('[#25778] NativeSQLStrategy — the duration measure as a statement', (
     for (const dialect of ['sqlite', 'postgres', 'mysql']) expect(native.canHandle(q(), nativeCtx({ dialect })), dialect).toBe(true);
   });
 
-  it('presents a client string as a number, and folds an empty sum to 0 while an empty avg stays null', async () => {
+  it('presents a client string as a number; an empty sum arrives as the statement\'s 0 and an empty avg stays null', async () => {
+    // [#25907] Category `c` has no record carrying both columns: the statement
+    // answered `COALESCE(SUM(…), 0)` (above), so the client hands back `'0'`.
     const rows = [
       { category: 'a', avg_hours: '12.75', total_seconds: '91800' },
-      { category: 'c', avg_hours: null, total_seconds: null },
+      { category: 'c', avg_hours: null, total_seconds: '0' },
     ];
     const res = await native.execute(q(), nativeCtx({ dialect: 'postgres', rows }));
     expect(res.rows).toEqual([