Fix various trino query things

e2e/support/start-mock-trino.ts

@@ -77,6 +77,17 @@ const routes: [string, object][] = [
       stats: { state: 'FINISHED' }
     }
   ],
+  [
+    // First page is empty; the follow-up page (served by GET below) exceeds MAX_CLIENT_ROWS.
+    'FROM huge_table',
+    {
+      id: 'q-huge',
+      columns: [{ name: 'id', type: 'integer' }],
+      data: [],
+      nextUri: `http://localhost:${PORT}/v1/statement/executing/q-huge/1`,
+      stats: { state: 'RUNNING' }
+    }
+  ],
   [
     'FROM nullable_table',
     {
@@ -108,6 +119,19 @@ http
       res.writeHead(204).end();
       return;
     }
+    if (req.method === 'GET' && req.url?.startsWith('/v1/statement/executing/q-huge/')) {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(
+        JSON.stringify({
+          id: 'q-huge',
+          columns: [{ name: 'id', type: 'integer' }],
+          data: Array.from({ length: 10_001 }, (_, i) => [i + 1]),
+          nextUri: `http://localhost:${PORT}/v1/statement/executing/q-huge/2`,
+          stats: { state: 'RUNNING' }
+        })
+      );
+      return;
+    }
     let body = '';
     req.on('data', (c: Buffer) => (body += c));
     req.on('end', () => {

e2e/trino/trino.spec.ts

@@ -36,6 +36,50 @@ test.describe('Trino query editor', () => {
     await expect(table.getByRole('cell', { name: '1' })).toBeVisible();
     await expect(table.getByRole('cell', { name: 'Alice' })).toBeVisible();
     await expect(page.getByText('Rows 1–3 of 3')).toBeVisible();
+    await expect(page.getByText(/^3 rows returned \|/)).toBeVisible();
+  });
+
+  test('hitting the row limit is reported in the status bar', async ({ page }) => {
+    await setTabSql(page, 'SELECT * FROM huge_table');
+    await page.goto('/trino');
+    await waitForHydration(page);
+    await page.locator('.monaco-editor').first().click();
+
+    await page.getByRole('button', { name: 'Run', exact: true }).click();
+    await waitForQueryComplete(page);
+
+    const status = page.locator('[data-query-state="FINISHED"]');
+    await expect(status.getByText('Row limit reached', { exact: true })).toBeVisible();
+    await expect(status.getByText(/^10,000 rows returned \|/)).toBeVisible();
+    await expect(status).not.toContainText('rows processed');
+    await expect(page.getByRole('table', { name: 'Query results' })).toBeVisible();
+    // A single statement's row limit is only reported in the status bar.
+    await expect(page.getByText(/query cancelled/)).toHaveCount(0);
+  });
+
+  test('row limit in a multi-statement script is reported on the affected statement', async ({
+    page
+  }) => {
+    await setTabSql(page, 'SELECT * FROM huge_table; SELECT id, name FROM users');
+    await page.goto('/trino');
+    await waitForHydration(page);
+    await page.locator('.monaco-editor').first().click();
+
+    await page.keyboard.press('Control+Shift+Enter');
+    await expect(page.getByRole('table', { name: 'Query results — Statement 2' })).toBeVisible();
+
+    const panelFor = async (index: number) => {
+      const toggle = page.getByRole('button', { name: `Toggle statement ${index} results` });
+      return page.locator(`[id="${await toggle.getAttribute('aria-controls')}"]`);
+    };
+    const warning = 'Row limit of 10,000 reached — query cancelled.';
+    await expect((await panelFor(1)).getByText(warning)).toBeVisible();
+    await expect((await panelFor(2)).getByText(warning)).toHaveCount(0);
+
+    // The status bar describes the last statement, which completed normally.
+    const status = page.locator('[data-query-state="FINISHED"]');
+    await expect(status.getByText('Finished', { exact: true })).toBeVisible();
+    await expect(status.getByText(/^3 rows returned \|/)).toBeVisible();
   });
 
   test('Ctrl+Enter triggers query execution', async ({ page }) => {

messages/de.json

@@ -84,7 +84,10 @@
   "trino_state_finished": "Abgeschlossen",
   "trino_state_failed": "Fehlgeschlagen",
   "trino_state_cancelled": "Abgebrochen",
-  "trino_progress_info": "{rows} Zeilen verarbeitet | {elapsed} s",
+  "trino_state_row_limit": "Zeilenlimit erreicht",
+  "trino_progress_info": "{rows} Zeilen zurückgegeben | {elapsed}",
+  "trino_elapsed_ms": "{value} ms",
+  "trino_elapsed_s": "{value} s",
   "trino_row_limit_reached": "Zeilenlimit von {limit} erreicht — Abfrage abgebrochen.",
   "trino_catalog_browser": "Katalogbrowser",
   "trino_catalog_browser_toggle": "Katalogbrowser ein-/ausblenden",

messages/en.json

@@ -84,7 +84,10 @@
   "trino_state_finished": "Finished",
   "trino_state_failed": "Failed",
   "trino_state_cancelled": "Cancelled",
-  "trino_progress_info": "{rows} rows processed | {elapsed}s",
+  "trino_state_row_limit": "Row limit reached",
+  "trino_progress_info": "{rows} rows returned | {elapsed}",
+  "trino_elapsed_ms": "{value} ms",
+  "trino_elapsed_s": "{value} s",
   "trino_row_limit_reached": "Row limit of {limit} reached — query cancelled.",
   "trino_catalog_browser": "Catalog browser",
   "trino_catalog_browser_toggle": "Toggle catalog browser",

src/lib/components/trino/StatementResult.svelte

@@ -1,7 +1,8 @@
 <script lang="ts">
   import { browser } from '$app/environment';
   import * as m from '$lib/paraglide/messages.js';
-  import type { QuerySnapshot } from '$lib/types/query';
+  import { getLocale } from '$lib/paraglide/runtime.js';
+  import { MAX_CLIENT_ROWS, type QuerySnapshot } from '$lib/types/query';
   import { initPageSize, type PageSize } from '$lib/types/pagination.js';
   import Pagination from '$lib/components/Pagination.svelte';
 
@@ -31,15 +32,13 @@
   const lastPage = $derived(totalPages - 1);
   const rowStart = $derived(currentPage * pageSize + 1);
   const rowEnd = $derived(currentPage * pageSize + displayedRows.length);
-  const stmtError = $derived(
-    result.error && !result.error.startsWith('ROW_LIMIT:') ? result.error : null
-  );
+  const stmtError = $derived(result.error);
+  const showHeader = $derived(totalStatements > 1);
   const rowLimitWarning = $derived(
-    result.error?.startsWith('ROW_LIMIT:')
-      ? m.trino_row_limit_reached({ limit: result.error.split(':')[1] })
+    showHeader && result.rowLimitReached
+      ? m.trino_row_limit_reached({ limit: MAX_CLIENT_ROWS.toLocaleString(getLocale()) })
       : null
   );
-  const showHeader = $derived(totalStatements > 1);
 
   const CSV_HEADERS_KEY = 'trino_csv_include_headers';
   let includeHeaders = $state(browser ? localStorage.getItem(CSV_HEADERS_KEY) === 'true' : false);
@@ -231,6 +230,9 @@
           ">{stmtError}</pre>
       </div>
     {:else if result.state === 'FINISHED' && result.columns.length > 0}
+      {#if rowLimitWarning}
+        <p class="text-warning text-xs">{rowLimitWarning}</p>
+      {/if}
       <div class="overflow-x-auto">
         <table
           class="table-zebra table-sm table"
@@ -262,9 +264,6 @@
           </tbody>
         </table>
       </div>
-      {#if rowLimitWarning}
-        <span class="text-warning mt-1 block text-xs">{rowLimitWarning}</span>
-      {/if}
       <div class="pt-2">
         <Pagination
           bind:pageSize

src/lib/server/trino/queries.ts

@@ -28,6 +28,7 @@ export interface TrinoQuery {
   progress: QueryProgress;
   columns: Column[];
   rows: unknown[][];
+  rowLimitReached: boolean;
   error: string | null;
   sql: string;
   startedAt: number;
@@ -51,7 +52,6 @@ export function toQueryProgress(stats: TrinoQueryStats | undefined): QueryProgre
   if (!stats) return INITIAL_PROGRESS;
   return {
     progressPercentage: stats.progressPercentage ?? 0,
-    processedRows: stats.processedRows ?? 0,
     elapsedTimeMillis: stats.elapsedTimeMillis ?? 0
   };
 }
@@ -120,6 +120,8 @@ function buildSnapshot(
     progress: query.progress,
     columns: lightweight ? [] : query.columns,
     rows: lightweight ? [] : query.rows,
+    rowCount: query.rows.length,
+    rowLimitReached: query.rowLimitReached,
     error: query.error,
     sql: query.sql,
     startedAt: query.startedAt
@@ -164,6 +166,7 @@ async function submitStatement(
     progress: toQueryProgress(submitResult.stats),
     columns: submitResult.columns ?? [],
     rows: submitResult.data ?? [],
+    rowLimitReached: false,
     error: null,
     sql,
     startedAt: Date.now(),

src/lib/server/trino/result-collector.test.ts

@@ -26,6 +26,7 @@ function makeQuery(client: Partial<TrinoQuery['client']>): TrinoQuery {
     progress: INITIAL_PROGRESS,
     columns: [],
     rows: [],
+    rowLimitReached: false,
     error: null,
     sql: 'SELECT * FROM big',
     startedAt: 0,
@@ -57,9 +58,10 @@ describe('collectResults row limit', () => {
 
     expect(cancelViaUri).toHaveBeenCalledWith('http://trino/next-3', 'alice');
     expect(cancel).not.toHaveBeenCalled();
-    expect(query.error).toBe(`ROW_LIMIT:${MAX_CLIENT_ROWS}`);
+    expect(query.rowLimitReached).toBe(true);
+    expect(query.error).toBeNull();
     expect(query.state).toBe('FINISHED');
-    expect(query.rows.length).toBeGreaterThanOrEqual(MAX_CLIENT_ROWS);
+    expect(query.rows.length).toBe(MAX_CLIENT_ROWS);
   });
 
   it('falls back to cancel(queryId) when the crossing page has no nextUri', async () => {
@@ -77,7 +79,45 @@ describe('collectResults row limit', () => {
 
     expect(cancelViaUri).not.toHaveBeenCalled();
     expect(cancel).toHaveBeenCalledWith('q1', 'alice');
-    expect(query.error).toBe(`ROW_LIMIT:${MAX_CLIENT_ROWS}`);
+    expect(query.rows.length).toBe(MAX_CLIENT_ROWS);
+    expect(query.rowLimitReached).toBe(true);
+    expect(query.error).toBeNull();
     expect(query.state).toBe('FINISHED');
   });
+
+  it('does not flag a result of exactly MAX_CLIENT_ROWS without further pages', async () => {
+    const cancelViaUri = vi.fn(async () => {});
+    const cancel = vi.fn(async () => {});
+    const poll = vi.fn(async () => ({
+      id: 'q1',
+      data: Array.from({ length: MAX_CLIENT_ROWS }, () => [1]),
+      nextUri: undefined,
+      stats: { state: 'FINISHED' }
+    }));
+
+    const query = makeQuery({ poll, cancelViaUri, cancel });
+    await collectResults(query);
+
+    expect(cancelViaUri).not.toHaveBeenCalled();
+    expect(cancel).not.toHaveBeenCalled();
+    expect(query.rowLimitReached).toBe(false);
+    expect(query.rows.length).toBe(MAX_CLIENT_ROWS);
+    expect(query.state).toBe('FINISHED');
+  });
+
+  it('flags exactly MAX_CLIENT_ROWS when more pages follow', async () => {
+    const cancelViaUri = vi.fn(async () => {});
+    const poll = vi.fn(async () => ({
+      id: 'q1',
+      data: Array.from({ length: MAX_CLIENT_ROWS }, () => [1]),
+      nextUri: 'http://trino/next-2',
+      stats: { state: 'RUNNING' }
+    }));
+
+    const query = makeQuery({ poll, cancelViaUri, cancel: vi.fn(async () => {}) });
+    await collectResults(query);
+
+    expect(cancelViaUri).toHaveBeenCalledWith('http://trino/next-2', 'alice');
+    expect(query.rowLimitReached).toBe(true);
+  });
 });

src/lib/server/trino/result-collector.ts

@@ -67,9 +67,19 @@ export async function collectResults(query: TrinoQuery): Promise<void> {
       return;
     }
 
-    // Row limit check.
-    if (query.rows.length >= MAX_CLIENT_ROWS) {
-      query.error = `ROW_LIMIT:${MAX_CLIENT_ROWS}`;
+    // Row limit check. Exactly MAX_CLIENT_ROWS only counts as truncated if more pages follow,
+    // otherwise e.g. `LIMIT 10000` would be flagged.
+    if (
+      query.rows.length > MAX_CLIENT_ROWS ||
+      (query.rows.length === MAX_CLIENT_ROWS && result.nextUri)
+    ) {
+      // The last page usually overshoots — keep exactly MAX_CLIENT_ROWS.
+      query.rows.length = MAX_CLIENT_ROWS;
+      query.rowLimitReached = true;
+      log.debug(
+        { trino_query_id: query.trinoQueryId, row_count: query.rows.length },
+        'row limit reached, cancelling query'
+      );
       try {
         if (result.nextUri) {
           await query.client.cancelViaUri(result.nextUri, query.trinoUser);

src/lib/types/query.ts

@@ -2,7 +2,6 @@ export const MAX_CLIENT_ROWS = 10_000;
 
 export const INITIAL_PROGRESS: QueryProgress = {
   progressPercentage: 0,
-  processedRows: 0,
   elapsedTimeMillis: 0
 };
 
@@ -24,7 +23,6 @@ export type QueryState =
 
 export interface QueryProgress {
   progressPercentage: number;
-  processedRows: number;
   elapsedTimeMillis: number;
 }
 
@@ -40,6 +38,10 @@ export interface QuerySnapshot {
   progress: QueryProgress;
   columns: Column[];
   rows: unknown[][];
+  /** Rows fetched so far. Populated even in lightweight snapshots, where `rows` is empty. */
+  rowCount: number;
+  /** Fetching stopped and the query was cancelled because MAX_CLIENT_ROWS was reached. */
+  rowLimitReached: boolean;
   error: string | null;
   sql: string;
   startedAt: number;