Skip to main content
The Parable Pool contains Plot results: the stored output of a Plot that a Report run materializes, and a view of every other Plot’s SQL. Each is addressed by the Parable that owns the Plot and the Plot’s own name:
For example:

The address of a Parable

{parable} is the Parable’s SQL address. Parable sets it when the Parable is created, from the Parable’s handle in lower case. The address of a Parable that Parable Directory publishes starts with directory_: A change of the Parable’s name does not move its address. Parable staff move it in two ways only: they put the Parable in the Parable Directory or take it out, and they rename its handle. Each change moves the address, rewrites the Parable’s own SQL to the new address, and publishes the rewrite as one new Version. A copy of the Parable in another Workspace takes that Version and reads the new address from then on. Until it does, the copy’s Plots that name the Parable’s other Plots by address do not run. The old address stops working at once. A query outside the Parable that names it, such as a saved Flight SQL query or an MCP query, fails until someone changes it. The old address then becomes free for another Parable of the Workspace. A Parable that entered the Parable Directory before this rule keeps its address while it stays in. It moves the next time staff put it in. Parable refuses the change while other Parables read the Parable, while a set of Changes is open on it, and when another Parable of a Workspace that has it already uses the new address. A declared Plot can register its output table before its first successful run. If a successful run produces no records, the result remains a table with a schema and zero rows rather than becoming a missing table.

Plots the Workspace cannot serve

The Workspace’s catalog reads its published Plots when it is built. When that read fails, the catalog serves every other table: Provider Pool, Artifact and Workspace tables, and Plots that do not read another Plot, answer as usual. A query that names a Plot the catalog does not serve fails with QL-TB-007 (UNAVAILABLE). The message names the table and why the Plots could not be read. The catalog cannot tell a Plot it could not read from a name that does not exist, so it gives this error for both. Try again: the catalog reads the Plots again within seconds, then less often while the read keeps failing, up to a few minutes. A publish or a Deploy of the Parable makes it read them at once. A published Plot whose table cannot be built, for example because its output schema does not map to a column type, or because another Plot has the same address, fails with QL-TB-008 (FAILED_PRECONDITION) for a reader its Pane admits. The message names the table, the Plot, the Parable and why. A reader its Pane refuses gets the same unknown-relation answer as for a name that matches no Plot. Each request checks current Pane access before it returns a failure reason. Under View as, both the previewed person’s access and the viewer’s own access apply. A collision diagnostic requires access to every Plot it names. Every other Plot is served. The Plot is served again after a Version that fixes it is published.

Plots that are views

A Plot that no Report run stores, and whose SQL binds no parameters, is a view: reading parables.{parable}.{plot} runs the Plot’s published SQL as part of the reading query, so one Plot can build on another without waiting for a stored result. A view serves the columns its Plot was planned with, checks the values of the columns the reading query reads against the Plot’s output contract, and applies the Plot’s Pane Policies before the reading query’s own filters. It computes only the columns the query reads. The reader needs access to the sources the view reads. Views can read views; views that read each other are refused.

Build on materialized results

Plots can read Provider and Artifact tables and materialize the result into the Parable Pool. Other queries and Plots can then reuse that result:
The Pane’s Perception declares the Plot’s reusable input and output contract. Each stored value a caller’s projection, filter, join, or aggregate reads must conform to that contract before the caller can consume it; a column the query does not read is not checked. An empty result still checks its columns. An absent contract refuses execution. A Plot’s own table and a Report run’s output have write and read checks. Parable checks every row before it writes when the run holds the Plot’s contract, as a Report run and a manual Plot run do; rows that break it are not written, and the run fails with QR-QU-011. A checked write records the contract that Parable checked it against. The read checks the rows again in each column the query reads whose contract says more than the column’s type, except as the paragraph below describes. Policies count as readers of their columns too; related-column contracts are checked whole. A Report artifact was checked when it was written; its read checks the contract and the stored bytes’ digest instead of the rows. The same rule covers Plots that join rows with embedding vectors. Parable checks the joined rows and filters them by current output Policies before the Plot exposes their columns. A vector alias does not bypass a filter on a different declared field. A read skips the row check when the last write replaced the whole table and Parable checked it against the contract the read expects. A table with no record, with a record for another contract, or whose last write kept earlier rows is checked as it is read. A Plot that joins embedding vectors is always checked. A read that skips the row check relies on the scalar rules in force when the Plot wrote the rows. Run the Plot again to check the rows against the current rules. A Pipeline (a Plot with requiresReportingRun) is served from the newest completed Report run whose output fits the published contract and the Plot’s planned columns, the same output a Current read selects, and is an empty table until such a run exists. A Refresh of another Parable that reads it reads the Refresh it recorded instead: the newest complete Refresh that completed by that Refresh’s AS OF time and fits the Release it reads (Read a Platform Parable’s Plots). The served output and its producing contract remain fixed. A reader must still hold the run’s access to every input it read: before the first row, as file batches are read, and at completion, including empty and fully filtered results and queries outside a Report reading. A narrower Policy or a source revocation ends the read with a refusal. Current output Policies also apply before a query can project or aggregate those rows. Report metadata also requires a current binding for each captured Plot input before exposing a stored row count. Removing that input hides the count; creating a different Plot with the same handle does not restore it.

Read the Parable beside a Platform Parable’s tab

A Platform Parable shows as a tab beside every Parable. Its Plots can read the Parable on screen beside the tab, the subject, through five relations in the subject catalog. The server checks the subject once for each read, then sends the rows with it. A read with no subject, such as a Plot read outside a tab, a check at Prepare or Publish, or the Plot editor, gets the same relations with the same columns and no rows. So a Plot that names them plans and checks everywhere: the Plot editor and the check at Prepare and Publish know each relation and its columns, and a column that a relation does not have is an error there, as for any other table. subject.changes and subject.public.changes name the same relation, as workspace.* names its tables.
The rows come from the tree that Ponder and Publish read for the revision on screen. A Pending Patch is its own Changes over the Parable as it is now. A Proposed Patch is the tree that Propose sealed: every Publish moves each Proposed Patch that has no conflict onto the new Release, so it is the tree that its Publish would apply. A copy’s Patch lies over the copy’s Release, which lies over its source’s Release. A Piece is in subject.changes when the Patch’s tree and the tree it lies over hold it differently: a Pending Patch lies over the Parable as it is now, and a Proposed Patch over the Release it was proposed or last moved onto. The Changes list and subject.changes use the same Patch comparison. A move onto a new Release does not replace the Patch’s own Changes with the changes that Release brought in. Source-file changes appear under their Page, Pane, Plot, or Palette in subject.changes. The relations list only the Pieces that the reader’s participation lists in the Pieces tree: Peeking lists Pages only, so its subject.pieces and subject.changes hold Pages alone, and subject.patch names only the people who changed a Page. The relations hold names and metadata, never Piece source. A read whose rows exceed 512 KiB is refused, with a message that names the cause. Answers are never shared across subjects: the read’s context names the subject, so its plan, its page cursor and its planning answers are its own.

Rows about the Parable beside the tab

A Pane can hold rows about another Parable, such as reviews of a Patch (Rows about a Parable). A Plot of the tab reads them by the Pane’s name, as parables.{parable}.{pane} and parables.{parable}.{pane}_by_actor, with the rule of every other read of these rows:
  • About the Parable beside the tab. A read returns the rows about the subject and about its Pieces, and only those that the reader can read. The reader must read the subject, as for the subject relations. For a row about a Piece, the reader’s Pieces tree must also list that Piece: Peeking lists Pages only.
  • One item, one subject. An item of parables.{parable}.{pane} shows only when each of its rows in the reader’s layers is about such a subject, so a row about another Parable never lends a field to it.
  • No subject, no rows. A read with no subject returns no row of such a Pane, by either name. This is a Plot read outside a tab, such as a Page of the Platform Parable opened on its own.
  • A Refresh reads none. A Refresh has no Parable beside it, so it reads no row about a subject.
  • Older definitions do not remove the rule. A Pane remains subject-bound when either the definition on screen or its current definition declares rows about a Parable. After removal, the newest accepted live definition of that Pane keeps its subject rule. Ordinary removed Panes keep their existing reads. If the retained type cannot be checked, that Pane’s Preferences do not read; unrelated Panes and Pane data keep their own rules.
  • Never across Workspaces. A shared read checks each contributing copy’s current Pane, including its exact upstream Release. A subject-bound Pane contributes no rows, including rows saved before it declared subjects. A missing or deleted current Pane also contributes no rows. Older shared reads therefore lose retained ordinary rows from that Pane, but the rows remain stored.
  • Never through workspace.preferences. workspace.preferences, and SQL that reads the stored rows directly, return no row of such a Pane, also for Publishing or Primary on the composed Platform Parable.
A check of a Platform Parable reads the rows about the Patch that it checks as Primary on that Patch’s Deployment. It counts a signed row only while the person who signed it is an active member of the Workspace. A check that counts independent reviews uses parables.{parable}.{pane}_by_actor. The plain Pane relation merges fields across the reader’s layers, so one merged item is not independent evidence from the signer of one stored row.

Read a Platform Parable’s Plots

A Plot can read the Plots of a Platform Parable by the same address. A Platform Parable is a Parable that Parable staff deploy to every Workspace, and only a Platform Parable can be read by other Parables. The SQL editor offers the Plots of the Platform Parables you may read. SQL that names a Plot of any other Parable is refused when you save, prepare or publish it, as SQL that names a table that does not exist.
The SQL names no Release and no Refresh. The read names them, as it does for the Parable’s own Plots:
  • A published Version reads the Release of the Platform Parable that was the newest in the Workspace when the Version was published. A view of the Platform Parable runs the SQL of that Release, so a later Release does not change what the view reads.
  • The next publish reads the newest Release. The publish is refused if the SQL does not plan against it.
  • Changes read the newest Release.
  • Latest reads, for a Pipeline of the Platform Parable, its newest Refresh whose output has the same columns as that Pipeline in the Release the read reads. Any Release with those columns can have made that Refresh. So when a later Release keeps a Pipeline’s columns and refreshes, the reading Parable shows the rows of the later Release, and the answer names that Release.
  • A Refresh of the reading Parable reads the Refresh of the Platform Parable that it recorded when it ran.
A request can name them, in two headers, for each Platform Parable the read reads:
A named Release must be the one the read reads. A named Refresh must be a completed run of that Parable whose output has the columns of that Release. It can be a Preview, which holds sampled rows. A Plot read’s answer names what it read:
  • x-parable-releases names every Release that made rows the read read. A view’s rows come from the Release the read reads, and a Pipeline’s rows from the Release that made its Refresh. So the answer names a Parable twice when those are two Releases. Do not send this answer back as a request header: a request names the Release the read reads, each Parable once.
  • x-parable-refreshes names the Refresh read of each Parable.
  • meta.parableReads lists the same reads, one for each Release and Refresh.
A SQL read lists them in the result schema’s parable.reads.parables metadata. A reader gets rows from a Platform Parable’s Plot only when they could read that Plot in the Platform Parable. While a Platform Parable is not Visible in the Workspace, it gives nothing there: its Plots read as empty tables. Another Parable cannot read a view that reads the Platform Parable’s own Pane data (<pane>_data). The read is refused with “Current access does not allow this Plot data”. Serve such rows to other Parables through a Pipeline, which they read from its stored Refresh. A read is refused, with a message that says why, when:
  • the Release it reads was retracted. A Retract is refused while the Version that a Workspace reads now reads that Release (Platform Parables);
  • the Parable it reads is no longer a Platform Parable. A Parable stays a Platform Parable while other Parables’ published Versions read it, so only an older Version or Changes get this refusal;
  • a header names a Release that the read does not read;
  • a Refresh of the reading Parable reads a Plot that a newer Release of the Platform Parable changed. Publish the reading Parable again to read the newest Release.
A Plot has no schedule of its own. A Report run refreshes its stored output, on demand or from a Report plan, and Report plans are the only schedule. Use catalog discovery to confirm the available columns and the latest successful materialization before depending on a result. See Plots for the product journey and the Plot Plugins primer for the execution capabilities a Plot can use.