The list
Each row shows:
Filters sit above the table: a time window (defaulting to the last 24 hours, up to the full 90-day retention), an engine, a state, an exact-match user (paste a name or an id), and one search box for the SQL text or a plain-language question. Column headers sort the table, but sorting and the search box are mutually exclusive. Once a search has answered, the order on screen is the relevance ranking, and re-sorting it would throw that away.
By default this page shows your own queries. Query text can hold literal values, restricted table and column names, and secrets, so seeing another person’s queries takes the tenant-audit permission, which the Account admin and Data admin roles carry. With it, the page shows every query run across the tenant; without it, the list, the search box, and any query you open by link are limited to the queries you ran, and the page tells you it is showing your own.A table’s History tab is the one place you see other members’ queries without that permission, because it answers who uses the table. It lists the recent queries that touched a table you can read, in the time window you pick, with who ran it, when, and its state, but, without the tenant-audit permission, shows the SQL text and error message only for your own queries. Another member’s query appears without them, and you cannot open its detail page. With the permission you see both, and you can open it.
Queries an installation ran for you
When you open a data app, the queries it runs on your behalf are recorded with you as the user, shown as your name followed by the app’s. The same rule applies to a task run by an installed agent on your behalf: its query belongs to you. These queries are shown only to you and to people with the tenant-audit permission. Everyone else does not see them anywhere: not in this list, not in search, not by opening the query’s link, and not in a table’s History tab, per-query table lineage, or the table’s Activity counts, people and latest-query link, even when they can read the table. A narrowed lineage or Activity response tells you that private app and agent queries from other people may be omitted, without revealing how many exist or who ran them. An installation chooses its own SQL, so its queries can carry values from the data you were shown, and hiding the whole query keeps those values with you. When a table’s History tab leaves out an app or installed-agent query like this, its notice names both kinds under the list. It never says how many were left out. If every query loaded so far was left out, the tab says there are none you can see rather than that the table has none, and keeps Load more when there are more queries to read, so later queries you can see are still reachable.Searching history
Typing in the search box asks the same fused ranking (keyword matching, plus similarity ranking when your deployment has an embedding provider configured) that backs the “Queries” group in the ⌘K search palette and thesearch_queries tool available to AI agents connected over MCP. A footer note tells you which mode actually answered: similarity ranking, or keyword matching if no embedder was available for that search.
Query-history search is part of the metadata_search entitlement. A workspace without that flag can still browse and open its query history, but the search box is refused — the same plan boundary that gates catalog search.
The
search_queries MCP tool needs the same permission as running SQL yourself, even though it only reads history and never executes anything. Like the Queries page, search_queries and get_query are limited to your own queries unless you hold the tenant-audit permission, which widens them to the whole tenant — so an agent connected on your behalf sees exactly what you would.Live and lost queries
A query that hasn’t finished yet appears with a Running state. Its detail page shows a live execution plan pulled directly from the engine, refreshed roughly every two seconds while you’re looking at it, rather than the completed-query view described below. Nothing about a running query’s cost (wall time, CPU time, bytes read) is known yet. Those numbers only exist once the query lands, so the page says so rather than showing zeroes. The live view follows the same rule as the rest of the page: you always see your own running queries, and seeing other members’ running queries — whose SQL text the engine returns in full — takes the tenant-audit permission (Account admin, Data admin, or a role you’ve granted it). Without it, another member’s running query is simply not shown to you. A query can also show as Lost: it started, and the platform never heard that it finished. This usually means the coordinator restarted, scaled to zero, or lost its connection mid-query, and the query itself may well have completed successfully. Nothing was ever measured for it, and there’s no way to recover that.The detail page
Open any row to see:- SQL: the full statement, with a copy button. Statements over 256 KiB are truncated in storage; a truncated one is labeled.
- Lineage: the tables and columns this query read and wrote, taken from the engine’s own reporting rather than parsed from the SQL. Written columns can expand to show which source columns they came from. A query that touched no attributable table (a literal
SELECT, a system-table read, a query that failed before resolving anything) says so plainly. - Execution: a timeline of where the wall-clock time went, an execution graph with a CPU-ranked operator table beside it, and any performance findings the platform noticed (a large join, spilling to disk, a skewed stage, a misestimated cardinality).
- Plan: the engine’s query plan, either as a diagram or as the engine’s own text, whichever you’d rather read. Copy always gives you the text form.
- Details: session catalog and schema, statement type, client info, and the created/started/finished/recorded timestamps.
PERMISSION_DENIED with Access Denied: some of the data this query reads does not exist or you do not have access to it. It never lists a table’s columns, never names a table behind a view, and never shows which names exist in tables other members can’t read. The exact engine error for a typo is still in the SQL workbench or your MCP result when you run the query.
Related
SQL workbench
Where most of the queries in this list get written and run.
Table lineage
How the same read and write events roll up into a table’s lineage graph.
Access log
The other screen under Activity: invitations, role changes, API keys and sign-ins.