Every tab in Explore is either an object you opened from the catalog browser or a query you wrote yourself. Open a blank query tab from the Explore entry in the sidebar, or click Open in SQL editor on any object’s page to start from a seeded SELECT. Results come straight from the engine to your browser. They never pass through the platform’s own servers, and they are filtered by your own grants, row filters and column masks exactly as they would be from any other SQL client.

Choosing an engine

Each query tab has its own toolbar with an engine picker, a catalog picker and a schema picker. There is no single, page-wide engine selector: the engine is a property of the query you are writing, not of the whole organization, so two tabs can run against two different engines side by side. The engine picker shows power state. A parked engine (scaled to zero) is still a perfectly good choice: running against it means the first query wakes it.

Running a statement

Press Run (⌘↵ on macOS, Ctrl+Enter elsewhere) or click the button. The results pane below the editor moves through a small number of states:
Cancelling a running query keeps whatever rows had already arrived. It stops the query; it does not throw away what you already have.

The engine-starting wait

If the engine you picked is parked to save you money, your first query starts it. This can take upwards of half a minute. The workbench keeps the statement waiting rather than dropping it: you don’t need to resubmit anything, and there’s no countdown or timeout on the wait, because the platform doesn’t promise a fixed number of seconds. Leave the tab open and it will run the moment the engine accepts connections.

Result limits

A single fetch returns up to 1,000 rows. If the engine has more, the footer offers Fetch more to pull the next page of the same query. There’s also a hard cap of 50 MB of result data per tab. If a statement returns more than that, the query is cancelled so it can’t keep working on data the tab cannot hold, and you’ll need to narrow the statement (fewer columns, a LIMIT, a WHERE) and run it again. Neither limit is configurable from the editor. There’s no query timeout on this surface. A slow query keeps running, and keeps polling, until it finishes, fails, or you cancel it.

When a result is governed

If a row filter or a column mask applies to your result, a note appears above the grid naming which columns were masked and which filters narrowed the rows. This is a courtesy, not the enforcement: the engine applies these before your browser ever sees a row, the same as it would for any other client.

Errors before you even run

The Run button is disabled, with a tooltip explaining why, when:
  • You haven’t typed a statement.
  • The engine registry couldn’t be read. This is a transient problem; the statement itself is safe, so retry in a moment.
  • Your organization has no query engine registered yet.
  • You haven’t chosen an engine for this tab.
  • The engine you chose has no address yet (still being provisioned).
A query that runs and fails for access reasons shows the engine’s own denial message verbatim: the same “Access Denied” you’d get from any SQL client hitting a table your role doesn’t grant. The message names the table, for example Access Denied: Cannot select from table sales.crm.customers, and never lists its columns. Ask an admin to grant your role access to that table. Reading a SECURITY INVOKER view without access to its underlying table is one such denial, and it can still name that table — see A SECURITY INVOKER view’s denial can still name its underlying table.

Can the workbench confirm names I don’t have access to?

Yes, one name at a time. Trino checks that every name in a statement exists before it checks your access to the table. So on a table your role doesn’t grant, a real column gets Access Denied, while a misspelled or made-up column gets Column '...' cannot be resolved. A table or schema that doesn’t exist gets its own “does not exist” error. The SQL workbench, data apps and JDBC or CLI clients show these errors exactly as Trino returns them. That tells you whether a table, schema or column name exists, but never returns any data from the table. MCP tools and query history don’t have this gap. On a table you can’t read, a wrong name there gets the same Access Denied answer as a real one. The answer names the table you typed in full (Access Denied: <table> does not exist or you do not have access to it), or otherwise says Access Denied: some of the data this query reads does not exist or you do not have access to it. If your role can read every table in the statement, you still get the exact “cannot be resolved” error for a typo.

Saving a query

Click Save query and give it a name. Any signed-in member can save a query; there’s no separate permission to unlock this. The name is what you’ll find it by again later, both here and in search, so it’s worth being specific (“Revenue by month” rather than “Query 1”). Only the statement is saved, never its results. A saved query keeps the tab’s engine, catalog and schema hints alongside the SQL. Once saved, the same button becomes Save (updates it in place), and Rename and Share buttons appear — for changing the name without changing the statement, and for widening who can read it. Saving is private to you by default. To let others open it, use the Share button that appears in the toolbar next to Rename once a query is saved. Sharing is scoped to a role: pick the role that should be able to read it (or type its name if you can’t list the tenant’s roles), and everyone holding that role can then open the query. Choosing Private — only you turns sharing back off. A link on its own grants nothing — the recipient must hold the role you shared with, or they’ll get “no such saved query”. Sharing is read-only and shares the statement text only, never its results and never your own access. Recipients cannot change the shared query: the Save and Rename buttons and the Share control are the owner’s, and the editor doesn’t offer them to a recipient. Instead a recipient sees a Read-only badge and a Save a copy button, which stores their own private, editable copy of the statement. Your open tabs and their unsaved drafts are kept in this browser and restored when you reload, so you don’t lose what you were typing to a refresh. One limit: a single draft longer than 100,000 characters is too large to keep this way. When a draft crosses that size the workbench tells you, and that tab’s text won’t come back after a reload — save the query, or copy the statement somewhere safe, before you leave the page. This affects only very large generated statements; ordinary SQL is nowhere near it.

Opening a saved query

Every saved query has a stable link of the form /explore/q/<id>. Opening one, whether you saved it or a teammate shared it with your role, seeds a new tab with its name, its SQL and its engine hints; it does not run automatically. Because sharing only shares the text of a query, not the sharer’s own access, you run it as yourself and may legitimately see different rows (or none) depending on your own grants. The link works only if the owner shared the query with a role you hold — pasting a link to a private query still reports “no such saved query”.

A known wake-up issue

Leaving an object’s Explore tab open in a background browser tab can, on its own and with nobody clicking anything, wake a parked engine again after it scales back down. If you notice an engine that never seems to stay asleep, check whether a stray Explore tab is open somewhere. This is a known issue and doesn’t yet have a fix.

Browse the catalog

Where a seeded query tab comes from when you preview or open an object in SQL.

Query history

Every query your engines ran, including the ones you write here.