One page per relation-name family, every page generated from the DDL (graphitron-model.sql): the family roster, its introductions and charters, the headline relations and the declared crossings from the meta_ rows, the per-object prose from the COMMENT ON text. The DDL is the only authored source; where prose elsewhere disagrees with it, the DDL wins.

Families

store_ The store’s own record (13 relations)

Every run of the generator leaves a record of itself here: which module it captured, which files it read, what configuration it held in hand, and where it wrote. The rows answer bookkeeping questions rather than schema questions: what was this store built from, and which graph do these facts belong to. When two runs disagree, this family is where you look up what each of them actually saw.

graphql_ Generic SDL transcription (29 relations)

A complete transcription of the GraphQL schema documents, as any SDL reader would see them. Every type, field, argument and directive application lands here exactly as written, with no judgment about what any of it means. The two judgment rows it does hold are the SDL toolchain’s own verdicts on whether the documents parse and validate at all.

graphitron_ The decoded graphitron reading (66 relations)

What the generator understands the author to have asked for. Each row is the decoded reading of one directive application: the same information that stands in the schema documents, restated in the generator’s own vocabulary so later questions can be asked with plain joins instead of re-parsing strings. Decoding is tolerant: a value that does not fit the declared shape is quarantined rather than lost.

sql_ The consumer database catalog (13 relations)

What the consumer’s database declares, read through the generated jOOQ model: schemas, tables, columns, keys, constraints, indexes and callables. These rows are the ground that written table and column references are checked against. A few rows also transcribe what the generated model states about itself, because that model ships as one unit with the catalog it was generated from.

jvm_ The declared classpath census (9 relations)

A census of the classes available on the declared compile classpath: the classes themselves, their public methods and parameters, their record components and supertypes. When the schema names Java code, this census is what the name is checked against. Presence says nothing about purpose; a class earns its row by being on the classpath, not by being used.

java_ The consumer’s Java sources (4 relations)

Where things are written in the consumer’s own Java sources: the position and documentation comment of each class, method and field declaration, from a plain parse of the source files. It exists so tools can point at a line in a file the author owns. It reads the sources rather than the compiled output deliberately, because the two answer different questions and may legitimately disagree.

javac_ The compile oracle’s verdicts (1 relation)

What the JDK compiler reported when the emitted sources were last compiled: one row per diagnostic, in the compiler’s own words. Each compile round replaces the previous one wholesale, so the family always describes the latest round and nothing older.

walk_ The legacy walk’s reach (1 relation)

What the legacy classification walk concluded, kept while that walk is being retired. The rows exist so new derivations can be checked against the old code’s answers during the migration; when the walk is gone, the family goes with it.

intent_ Derived intent (126 relations)

The derivation layer: what follows once the schema’s readings, the database catalog and the classpath census are put side by side. Rows here are computed, never captured; each view states one rule, and taller derivations are built by reading shorter ones. This is the family the generator and the editor tooling actually plan from.

rejection_ The legacy walk’s verdicts (2 relations)

The legacy walk’s error verdicts, in the sealed rejection hierarchy’s own vocabulary. Transitional by construction: each kind of verdict moves out as its detection is rebuilt store-native, and the family empties as that migration completes.

lint_ The linter’s findings (3 relations)

The linter’s findings: one row per finding, plus the corrections a rule can compute for its own findings. A correction here is a suggestion an editor may offer, never a rewrite the build performs. The family speaks the linter’s vocabulary, where severity follows from the rule.

build_warning_ The advisory arm (1 relation)

The advisory arm of build feedback: warnings that point at nothing rule-shaped, just a message and a location worth a human’s attention. Small on purpose.

meta_ The schema describing itself (8 relations)

The schema describing itself: which families exist, where the exceptions live, and how the roster closes against the relations actually observed. These rows are versioned with the schema definition and never change at run time. The reference pages you are reading are rendered from this family’s rows and the comments beside them.

Outside every family

The diagnostics stratum’s read surface unions five arms across four families' vocabularies; a read-side union across vocabularies has no family, so it renders on the reference’s index, the one cross-family surface.

diagnostic (view)

The diagnostics stratum’s one read surface: the union of all seven arms (the rejection residue, the store-native claim-conflict pilot, the lint arm, the advisory arm, the parser and the SDL toolchain’s two document-wide stages, the compile oracle), which the MCP diagnostics tools read and no consumer bypasses. Prefix-less on purpose: a read-side union across vocabularies has no family, and no naming gate says so mechanically, so this comment does. Derived columns live here rather than in the base relations: actionable is the deferred-versus-rest CASE over kind (the same predicate the LSP severity projection documents, pinned by a one-row parity assertion); severity for compile rows mirrors CompileDiagnostic.severity() (ERROR to error, every other javac kind to warning, same parity discipline); coordinate is the rendering of the stored pair, and it is the one composite here because its atoms ride the same row (type_name is a dimension of its own, field_name beside it), so every question the parts answer stays answerable from the row; the compile arm’s sentinels ("(no source)", -1) normalise to the uniform NULL absent bucket by comparing against the sentinel values, never IS NULL. lsp_code carries the producing oracle’s stable machine code in both namespaces (the rejection sub-seals' lspCode(), javac’s Diagnostic.getCode()), which cannot collide. Two axes are deliberately absent, both for the same reason and neither recoverable from a column that carried them: the claiming directives of a conflict, which are rows on the claim views and the residue’s own directive child under each arm’s key, so a consumer asks membership by joining rather than set equality against a joined string; and the directory of file, which is one segment of a path kept while the rest are discarded, so a consumer truncates the stored path at whatever depth its own question needs. Every dimension is single-valued at one row per diagnostic, so group counts sum to the row count.

Columns
graph_name (CHARACTER VARYING, nullable)

the owning graph’s partition, carried through from every arm; the MCP read site filters to the reading session’s graph

source (CHARACTER VARYING, nullable)

the closed channel taxonomy the shipped tool already speaks: schema for the six validator-side arms, compile for the javac arm

severity (CHARACTER VARYING, nullable)

error or warning, the wire’s closed pair: the rejection arms are error by the build’s own finality, lint and advisory rows warning by construction, compile rows javac’s verdict projected as the record’s severity() spells it

actionable (BOOLEAN, nullable)

the triage headline: FALSE exactly on DEFERRED rows (recognised but not yet generator-supported, a workaround rather than a schema fix), TRUE everywhere else including warnings and compile rows

kind (CHARACTER VARYING, nullable)

RejectionKind.name() on rejection-bearing rows (residue and pilot); NULL on lint, advisory and compile rows, where the three-way fork does not apply

variant (CHARACTER VARYING, nullable)

the producing oracle’s error-class dimension, in whichever of two namespaces minted the row: the rejection leaf’s package-stripped class name on rejection-bearing rows (rejection_validation_error.variant’s spelling rule), and graphql-java’s own error class name on the SDL toolchain’s arms (the constant InvalidSyntaxException on parser rows, since that stage has exactly one way to refuse; graphql_schema_error.error_class on the document-wide arms). The namespaces cannot collide, a rejection leaf keeping its enclosing classes and so always dotted where graphql-java’s are bare, which is the same argument lsp_code makes for carrying two code namespaces in one column. NULL on the lint, advisory and compile arms

lsp_code (CHARACTER VARYING, nullable)

the stable machine code of the row’s producing oracle: the rejection sub-seals' lspCode() on schema rows that declare one, javac’s Diagnostic.getCode() on compile rows; NULL where neither publishes a code

attempt_kind (CHARACTER VARYING, nullable)

which lookup space a name resolution failed in (AttemptKind.name()), on UnknownName rows only

attempt (CHARACTER VARYING, nullable)

the name the author wrote, on UnknownName rows only

stub_key (CHARACTER VARYING, nullable)

the deferred row’s stubbed-variant anchor; NULL off Deferred rows and on inline-defer sites naming no leaf class

lint_rule (CHARACTER VARYING, nullable)

LintRule.id() on lint rows; NULL elsewhere, including the advisory arm, whose rows are precisely the warnings no rule tags

type_name (CHARACTER VARYING, nullable)

the coordinate’s owning type, the coarse grain of the coordinate axis; NULL on rows carrying no schema coordinate

field_name (CHARACTER VARYING, nullable)

the coordinate’s field name, NULL at the type grain and on coordinate-less rows

coordinate (CHARACTER VARYING, nullable)

the rendered coordinate (a type name or Type.field), computed from the stored pair; the fine grain of the coordinate axis

file (CHARACTER VARYING, nullable)

path of the row’s source (SDL file on schema rows, generated .java on compile rows), one spelling across both channels and the one every arm stores, so this column derives from its arm rather than converting it; NULL in the stated absent bucket (whole-build findings, unlocated rejections, javac’s no-source sentinel)

source_line (INTEGER, nullable)

the location’s line, 1-based in both channels; NULL in the absent bucket (javac’s NOPOS normalised here)

source_column (INTEGER, nullable)

the location’s column, on the same terms as source_line

message (CHARACTER VARYING, nullable)

the row’s rendered message, whichever oracle authored it; display material, never a dimension, never an agreement anchor