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 withQL-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: readingparables.{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: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 thesubject 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.
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, asparables.{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
subjectrelations. 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.
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.- 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.
x-parable-releasesnames 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-refreshesnames the Refresh read of each Parable.meta.parableReadslists the same reads, one for each Release and Refresh.
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.