The decoded graphitron reading

The table a type is bound to, as one row per type however many @table applications the corpus wrote on it.

@reference on a field or input field: one row per application, because an application is a fact of its own.

The tolerant-decode overflow: a graphitron application argument whose literal does not fit the declared shape decodes to NULL in its typed column and quarantines its raw text here, so the authored value is never lost and the malformed-literal detection has its row.

Which of a graph’s types are node types: the union of the authored @node population and the resolved one.

A written key reference meets the constraint census case-insensitively under the resolver’s namespace precedence: a qualifier binds hard, the SQL constraint name answers first, and the generated Keys-class constant is eligible only where no SQL constraint answers the name.

A written table reference meets the catalog census by case-insensitive match on pre-normalized spelling columns, one row per candidate.

An argMapping path segment meets column names case-insensitively along the binding walk.

94 foreign keys from this family’s rows into that one.

93 foreign keys from this family’s rows into that one.

14 foreign keys from this family’s rows into that one.

1 foreign key from this family’s rows into that one.

1 foreign key from that family’s rows into this one.

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the schema coordinate the argMapping is written at, spelled as the GraphQL specification spells one and anchored by graphql_element: Type.field where a directive sits on a field, Type.field(argument:) where it sits on an argument, and InputType.field where it sits on an input field. A directive location and never a container, which is the difference from what this column held before: the three shapes are the three placements argMapping reaches capture from, so a reader wanting the parts joins the coordinate relation rather than reading a decomposition kept beside the spelling.

the right-hand side an author writes to name this element at this coordinate, from its head down, dot-separated. Every row is something writable, so no path is empty: a root is a row whose parent_path is null, not one whose path is blank. An entry’s written path meets its candidate on this column exactly, with no head to strip first and no prefix probe to rank.

the path one segment shorter, NULL at a root; a foreign key back to this relation, so a subtree is deleted by deleting what it hangs from. This is what says a row is a root, and no blank path stands in for it

the last segment of the path, which is what this row’s own element is called. At a root it is the whole path. An entry naming one thing below a resolved position meets this column, so the completion set at a position is the names of that position’s children

what this row’s own element is: ARGUMENT for a field’s argument, INPUT_FIELD for a field of an input type, SIGIL for a value the runtime holds. A property of the element rather than of the coordinate it is written at, so a reader switching on it needs no depth test, and the two nullnesses beside it are stated against this column. An argument and a sigil have no declaring type, so neither carries a container; a sigil names no GraphQL type, so it carries no named type either.

the type this candidate’s element is declared on, NULL where the element is an argument or a sigil and no type declares it

the type of the value at this candidate, unwrapped of list and non-null. The whole of what says whether anything opens below: a candidate whose type is an input object has children and every other candidate is a leaf, so a reader needs no separate kind column and no rule of its own

whether the value at this candidate is a list, carried from the argument or input field it stands for. A consumer binding a parameter to this candidate needs the arity as much as the type, and reading it here is what keeps such a consumer from joining back to the SDL relation the writer already read

how many segments below the root this candidate sits, zero at a root; carried because a reader ranking how far a path resolved compares it rather than counting separators

whether this candidate’s type already stands above it on its own ancestry, which is what makes it the element that closes a cycle. Such a candidate is nameable and so has a row, and nothing below it does, so this column is the difference between a leaf and a stopping point and a reader never has to infer one from the absence of children. Cyclic input nesting is not supported yet and the refusal an author sees is stated over these rows: a true here is where the candidate set stops, and saying so is what keeps the deferral visible instead of silent

whether this spelling repeats the coordinate’s own name as its head, which every argument-level and input-field-level argMapping in the wild does today and which the clean spelling beside it replaces. A candidate all the same, because refusing what authors have already written is not this relation’s business: both spellings resolve and this column is what lets a warning tell them apart. False at every candidate under a field coordinate, where a head names an argument and repeats nothing, and false on the coordinate’s own name, that being the only spelling for binding the whole value

whether more than one reading produced this exact spelling at this coordinate, the surviving row being the one the resolution picked. The relation cannot hold both because an author cannot write both, so the loser is not a row and this column is what keeps its absence from being silent. Which other reading it was needs no column of its own, both being recoverable here: the deprecated reading of a dotted spelling is the row at the same coordinate whose path is this one with its head removed, and the other reading of the coordinate’s own name is the coordinate itself

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

which kind of site declared the entry, in a closed vocabulary of nine, one per directive that can carry argMapping. The whole of what says how to read ordinal and step_position beside it, exactly as code_method_parameter.role does for its four, and the whole of what says which of the nine a coordinate’s two shapes came from, three of them sitting on an argument and six on a field. A reader that means one kind filters on it and owns having chosen

the site spelled as one string, in the site’s own grammar: Type.field, Type.field(argument), Type.field#ordinal, or those with the step position appended in brackets. Total by construction, which is what lets it key this relation where the decomposed columns beside it cannot, three of them being null on the sites that have no such part. A reader joining on the parts joins the parts; this column is the key and the thing a diagnostic prints

the schema coordinate the site sits on, spelled as the specification spells one and anchored by graphql_element: Type.field at the seven sites that sit on a field, Type.field(argument:) at an argument-level condition, and InputType.field at an input-field-level one. What the candidate relation is keyed by, so an entry meets what it may name on an equality over this column and the path, and the scope test two readers used to spell as a comparison against argument_name or field_name is that equality now.

which application of a repeatable directive the site is, null exactly on the sites that are not repeatable. Determined entirely by site, as argument_name is

the path element’s position within its reference, null exactly on the sites that are not a path element. Determined entirely by site, as the two above are

the pair’s own position in the site’s argMapping list, completing the key. Positional because argMapping is a list and the parameter it binds is identified by where it stands

the method parameter name the pair binds

the right-hand side as the author wrote it, verbatim. Named for what it is rather than for an argument, which the two site kinds that sit below one do not have: an argument-level condition writes a path relative to its own argument and an input-field-level one relative to its own field, so the leading name is not always an argument and the column no longer says it is. The three split columns beside it are the engine’s reading of this one and nothing else is stored twice.

the first segment of the written path, which at the sites rooted on a field is the argument the value enters through. Generated, so nothing writes it and nothing can. Read by the two relations that ask which argument feeds a parameter; it is not what resolution joins on, resolution being against the whole path.

the written path with its last segment removed, NULL where the path is a single segment and there is nothing above it. Generated. The position an author had resolved when the whole path does not: a path whose head is a candidate and whose whole is not names one thing beyond a position that exists, which is the key-column projection and the unknown-column defect, and this column is how both are found without a stored decomposition of the path.

the last segment of the written path, which is the whole of it where there is only one. Generated. With head_path beside it this is the one name past a resolved position, and it is what a key column is matched against.

the upper-cased form of the column beside it, for the one crossing in this schema where an authored spelling meets a catalog name: a trailing name matched against a node type’s resolved key columns, GraphQL being case-sensitive and SQL column names not. Generated, so nothing writes it and nothing can, and the expression is the neighbour’s repeated rather than read, a generated column not being allowed to read another. Folded here rather than wherever the comparison happens because this is the relation that owns the authored spelling; a view that carried the name onward would have to fold it per row, which is what happened when the decomposition this replaced was deleted.

the file the owning site was written in, carried from that site so a reader of this relation needs no join back to it

the owning site’s line, carried with the file beside it

the owning site’s column, carried with the file beside it

the owning graph’s partition, carried from the entry

which SDL site spelled the entry, in graphitron_argmapping_entry’s closed vocabulary of nine; with the use-site key and the position this is the grain, and it is what a consumer switches on to know whether an emitter is wired for the answer

the consuming coordinate, serialized as graphitron_argmapping_entry serializes it; the coordinate a rejection about this entry names, and the key a reader joins that relation on to recover the site’s own components

the spelling site’s owning type, decomposed from the entry’s coordinate rather than kept beside it

the spelling site’s field name within that type

the entry’s 0-based position within its own argMapping list

the candidate’s own path: the whole written path where all of it resolved, and that path less its last name where one name is left over. The whole of what this relation resolved, and the only path on it. Which of the two readings answered is this column against the entry’s written_path, equal or not, so a reader learns it by comparing what resolved with what was written rather than by reading a name this relation copied forward. What the author wrote stays on the entry, where the key here reaches it in one join and where a stored fold can sit beside it

ARGUMENT where the bound candidate is a field argument, INPUT_FIELD where it is an input field; carried from the candidate, and what tells an emitter which slot the wire value is read out of

the bound element’s owning type: the input type declaring an input field, and the object type declaring the field whose argument this is, the latter decomposed from the coordinate rather than kept beside it

the field owning the argument on an ARGUMENT binding, the input field itself on an INPUT_FIELD one

the argument’s name on an ARGUMENT binding; NULL on an INPUT_FIELD one, whose key needs no argument component

whether the bound element carries a @nodeId at all. FALSE is the ordinary binding, where the wire value is the value and no decode is implied; TRUE says a decode is, and the column beside it says whether the author named what to decode against. Kept as its own column rather than read off a NULL node type, because the two NULLs mean opposite things and a reader collapsing them would treat the bare spelling as an ordinary binding, which is the silence the projection exists to close

the typeName: the bound element’s @nodeId names, as written; NULL where the directive is absent, and NULL where it is present without one, which at this position is a rejection rather than an inference, there being no containing table to infer a node type from. Read with node_id_declared, never alone

the bound element’s own SDL named type, wrappers stripped, carried from the candidate. What a message needs in order to say what the author tried to open: an ID that declares no @nodeId is told to annotate it, while a String is told it has nothing to open at all, and those are two remedies for one shape

whether the bound element’s SDL type carries a list wrapper. Read where the binding is a node id with one name trailing: a list of node ids names the list of that key column across the decoded ids, which is a coherent request and not an author mistake, so nothing here rejects it and the consumer that knows which emitters exist defers on it

the owning graph’s partition, carried from whichever arm supplied the row

owning type of the field the argument sits on

the field the argument sits on, anchored by graphitron_field

the argument’s name within the owning field; with the three columns above, the grain

this row as graphitron_element spells it, Type.field(argument:) in the specification’s grammar, the trailing colon included because the specification writes it

the argument’s position within its field, declaration order on an authored one and the order the macro appended on a minted one, which is after every authored argument

the type expression as the generator reads it

that expression’s named type with its list and non-null wrappers stripped, which is the column readers actually join on

whether the outermost wrapper is non-null

whether the expression is a list

whether a list’s item is non-null; NULL where the expression is not a list, which the CHECK holds

the default literal where the argument has one, authored or written by the macro; display material, never a dimension

the docstring, authored or macro-written; display material, never a dimension

the owning graph’s partition, carried from the transcription

the type the owning field is declared on

the field the argument belongs to

the argument’s own name

Type.field(argument:), the specification’s spelling, the trailing colon included because the specification writes it

where the author wrote it among the field’s arguments

the type expression as written, wrappers included

the name at the bottom of that expression

whether the outermost wrapper is non-null

whether the expression is a list

whether a list’s items are non-null, and nothing where it is not a list

the default as written, or nothing

the docstring the author wrote, or nothing

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the argument name within the owning field

the SDL file the row was captured from

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

the name argument as written

the upper-cased form of the column beside it, for the case-insensitive match against sql_column’s column_name_upper and jooq_name_upper. Generated, so nothing writes it and nothing can. It exists for the reason its field-site twin does: an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the owning graph’s partition, carried from graphql_argument

the type owning the field the resolved argument sits on

the field the resolved argument sits on

the resolved argument’s name within the owning field; part of the grain with the resolved table, the scope this reads keying the site that way

the effective name this resolved: the @field(name:) binding where one decoded, else the argument name. What the author wrote, so a diagnostic naming the unresolved spelling reads it here rather than deciding which of the two applied

which tier matched: JOOQ_NAME (the generated Java field name) or SQL_NAME. Makes the two-tier precedence observable rather than only its outcome

witness: the resolved table’s catalog partition, the first column of the sql_column key this row names

witness: the resolved table’s SQL schema

witness: the resolved table’s SQL name. Which navigation reached it is graphitron_argument_column_scope’s basis, and a consumer emitting the predicate needs both

witness: the matched column’s SQL name. With the three columns above this is sql_column’s full key, so the column’s type and nullability are one join away

the argument’s own declaration file; the position a diagnostic would carry

source line of the argument declaration, 1-based

source column of the argument declaration, 1-based

the graph_name of a row of this rule, which the stage inserts into graphitron_argument_column_match.graph_name, whose comment carries what the value means

the type_name of a row of this rule, which the stage inserts into graphitron_argument_column_match.type_name, whose comment carries what the value means

the field_name of a row of this rule, which the stage inserts into graphitron_argument_column_match.field_name, whose comment carries what the value means

the argument_name of a row of this rule, which the stage inserts into graphitron_argument_column_match.argument_name, whose comment carries what the value means

the matched_name of a row of this rule, which the stage inserts into graphitron_argument_column_match.matched_name, whose comment carries what the value means

the matched_by of a row of this rule, which the stage inserts into graphitron_argument_column_match.matched_by, whose comment carries what the value means

the table_source_name of a row of this rule, which the stage inserts into graphitron_argument_column_match.table_source_name, whose comment carries what the value means

the table_schema of a row of this rule, which the stage inserts into graphitron_argument_column_match.table_schema, whose comment carries what the value means

the table_name of a row of this rule, which the stage inserts into graphitron_argument_column_match.table_name, whose comment carries what the value means

the column_name of a row of this rule, which the stage inserts into graphitron_argument_column_match.column_name, whose comment carries what the value means

the source_name of a row of this rule, which the stage inserts into graphitron_argument_column_match.source_name, whose comment carries what the value means

the source_line of a row of this rule, which the stage inserts into graphitron_argument_column_match.source_line, whose comment carries what the value means

the source_column of a row of this rule, which the stage inserts into graphitron_argument_column_match.source_column, whose comment carries what the value means

the owning graph’s partition, carried from both rules' base relations

the type owning the field the argument sits on. Not the type whose binding started the navigation, which is the field’s named type: the difference from the field-site twin, where the two are one

the field the argument sits on

the argument whose site this row resolves; part of the grain with the resolved table below, so two arguments of one field each get their own row and neither reader has to know they agree, and one argument resolving against a branch each of a multi-table polymorphic root gets one row per branch

which rule resolved this site, in a closed vocabulary of two disjoint rules: PATH_TERMINAL (an authored argument-site @reference path’s terminal element), ARGUMENT_SCOPE (the argument’s own scope table, no path element written). Also the fork a predicate binding takes, PATH_TERMINAL being exactly the case where the resolved table is not the one the field already selects from. Which rule answered underneath ARGUMENT_SCOPE is graphitron_argument_scope_table’s own basis and is deliberately not restated here, a reader wanting it joining the relation that states it; PARTICIPANT_TABLE there is what makes one argument resolve on several tables under this basis

the resolved table’s catalog partition, the first column of the sql_table key this row names

the resolved table’s SQL schema

the resolved table’s SQL name. With the two columns above this is sql_table’s full key, so the table’s columns are one join away

the graph_name of a row of this rule, which the stage inserts into graphitron_argument_column_scope.graph_name, whose comment carries what the value means

the type_name of a row of this rule, which the stage inserts into graphitron_argument_column_scope.type_name, whose comment carries what the value means

the field_name of a row of this rule, which the stage inserts into graphitron_argument_column_scope.field_name, whose comment carries what the value means

the argument_name of a row of this rule, which the stage inserts into graphitron_argument_column_scope.argument_name, whose comment carries what the value means

the basis of a row of this rule, which the stage inserts into graphitron_argument_column_scope.basis, whose comment carries what the value means

the table_source_name of a row of this rule, which the stage inserts into graphitron_argument_column_scope.table_source_name, whose comment carries what the value means

the table_schema of a row of this rule, which the stage inserts into graphitron_argument_column_scope.table_schema, whose comment carries what the value means

the table_name of a row of this rule, which the stage inserts into graphitron_argument_column_scope.table_name, whose comment carries what the value means

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the argument name within the owning field

0-based position within the owning list

the context argument name as written

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the argument name within the owning field

the SDL file the row was captured from

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

the fully-qualified Java class name as written

the Java method name as written

the argMapping string as written; the pair child is its decode

as written; NULL when omitted (the FALSE default is derivable)

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the argument name within the owning field

the SDL file the row was captured from

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

the owning graph’s partition, carried from the minting row

the type the owning field is declared on

the field the argument belongs to

the argument’s own name

Type.field(argument:), on graphitron_argument_authored.coordinate’s terms

where the expansion put it among the field’s arguments

the type expression the expansion wrote, wrappers included

the name at the bottom of that expression

whether the outermost wrapper is non-null

whether the expression is a list

whether a list’s items are non-null, and nothing where it is not a list

the default the expansion wrote, which is where a page size comes from; carried rather than nulled, unlike the field set, because pagination arguments are exactly the place a macro does write one

the docstring the macro wrote

the same fact as graphitron_argument_minted.graph_name, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_argument_minted.type_name, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_argument_minted.field_name, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_argument_minted.argument_name, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_argument_minted.coordinate, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_argument_minted.ordinal, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_argument_minted.type_sdl, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_argument_minted.named_type, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_argument_minted.non_null, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_argument_minted.is_list, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_argument_minted.item_non_null, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_argument_minted.default_value_sdl, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_argument_minted.description, before the conflict and stand-down filters have withheld anything

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the argument name within the owning field

the SDL file the row was captured from

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

the typeName argument as written; author-spelled, no FK

the owning graph’s partition; the leading key dimension that keeps one workspace’s graphs apart

the reachable input type’s name, which with the graph is the grain. One row per type however many arguments and input fields reach it, the reaching paths being what the recursion consumes rather than what it reports

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the argument name within the owning field

capture-assigned position in document order

the SDL file the row was captured from

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the argument name within the owning field

capture-assigned position in document order

the SDL file the row was captured from

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

the type argument as written; author-spelled, no FK. Names a participant of the polymorphic type the owning field returns

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the argument name within the owning field

the owning @referenceFor application’s ordinal

0-based position within the owning list

the table name as written (may carry a schema qualifier)

left of table_ref’s first period, NULL when no period appeared and the empty string when one appeared with nothing before it; for a table name this namespace is the SQL schema in every dialect jOOQ models. Written by capture, because splitting on a period is a decode and decodes happen there

right of table_ref’s first period, or the whole value when none; the empty string when a period was written with nothing after it, which joins nothing and is meant to

the constraint name as written (may carry a schema qualifier)

left of key_ref’s first period, NULL when no period appeared and the empty string when one appeared with nothing before it. This qualifier does not name the constraint’s own schema, because a constraint has none: it is scoped to its table, which is why sql_constraint takes its schema through the table. It names which schema’s table holds the constraint, disambiguating a constraint name that occurs in more than one, and the resolver reads it that way. Which namespace that is is dialect-dependent (the schema namespace in Oracle, the table namespace in PostgreSQL), which is why the column is not called a schema part

right of key_ref’s first period, or the whole value when none; joins sql_constraint.constraint_name narrowed by the source table the walk is standing on, not by this row alone

the fully-qualified Java class name as written

the Java method name as written

the argMapping string as written; the pair child is its decode

the upper-cased form of the column beside it, for the case-insensitive match against sql_table’s schema and name. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the upper-cased form of the column beside it, for the case-insensitive match against sql_table’s schema and name. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the upper-cased form of the column beside it, for the case-insensitive match against sql_constraint.table_schema_upper, the schema of the table holding the constraint. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the upper-cased form of the column beside it, for the case-insensitive match against sql_constraint’s constraint_name_upper and jooq_name_upper, in that precedence. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the argument name within the owning field

the owning @reference application’s ordinal

0-based position within the owning list

the table name as written (may carry a schema qualifier)

left of table_ref’s first period, NULL when no period appeared and the empty string when one appeared with nothing before it; for a table name this namespace is the SQL schema in every dialect jOOQ models. Written by capture, because splitting on a period is a decode and decodes happen there

right of table_ref’s first period, or the whole value when none; the empty string when a period was written with nothing after it, which joins nothing and is meant to

the constraint name as written (may carry a schema qualifier)

left of key_ref’s first period, NULL when no period appeared and the empty string when one appeared with nothing before it. This qualifier does not name the constraint’s own schema, because a constraint has none: it is scoped to its table, which is why sql_constraint takes its schema through the table. It names which schema’s table holds the constraint, disambiguating a constraint name that occurs in more than one, and the resolver reads it that way. Which namespace that is is dialect-dependent (the schema namespace in Oracle, the table namespace in PostgreSQL), which is why the column is not called a schema part

right of key_ref’s first period, or the whole value when none; joins sql_constraint.constraint_name narrowed by the source table the walk is standing on, not by this row alone

the fully-qualified Java class name as written

the Java method name as written

the argMapping string as written; the pair child is its decode

the upper-cased form of the column beside it, for the case-insensitive match against sql_table’s schema and name. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the upper-cased form of the column beside it, for the case-insensitive match against sql_table’s schema and name. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the upper-cased form of the column beside it, for the case-insensitive match against sql_constraint.table_schema_upper, the schema of the table holding the constraint. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the upper-cased form of the column beside it, for the case-insensitive match against sql_constraint’s constraint_name_upper and jooq_name_upper, in that precedence. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the owning graph’s partition, carried from the hop view

the type owning the field the argument sits on. Not the type whose binding started the chain, which is the field’s named type: the difference from the field-site sibling, where the two are one

the field owning the argument the @reference is applied to; also the field whose named type’s binding started the chain

the argument the @reference is applied to

the owning @reference application’s ordinal, as on the hop view

the element’s 0-based position within its application’s path; positions are contiguous from 0 up to wherever the chain stopped

which arm resolved the element, as on the hop view: KEY, TABLE, NAME_MATCH or CONDITION

for a KEY element, the namespace that answered; NULL on a TABLE, NAME_MATCH or CONDITION element. As on the hop view

the departing table’s catalog partition; the argument’s own scope table at position 0, the previous element’s arrival after that

the departing table’s SQL schema

the departing table’s SQL name

the arriving table’s catalog partition, first column of its sql_table key

the arriving table’s SQL schema

the arriving table’s SQL name. At the path’s last position this is the table the argument’s own column name resolves against, which is where a filter predicate binds

the foreign key this element joins on, named or discovered; NULL on a NAME_MATCH or CONDITION element, as on the hop view

TRUE when the departing table declares the foreign key; the element’s direction. NULL on a NAME_MATCH or CONDITION element, as on the hop view

how many distinct tables this element reaches, this row’s arrival being one of them; 1 where the destination is certain. Separate from candidates for the reason the field-site sibling states: an element with three foreign keys connecting the same pair of tables reaches one table by three routes, and a reader that only needs the destination can trust that where one that has to render the join cannot

how many rows this element resolved to, counting routes and not just destinations; 1 is the requirement for an expressible hop

the graph_name of a row of this arm, presented on graphitron_argument_reference_step_target.graph_name, whose comment carries what the value means

the type_name of a row of this arm, presented on graphitron_argument_reference_step_target.type_name, whose comment carries what the value means

the field_name of a row of this arm, presented on graphitron_argument_reference_step_target.field_name, whose comment carries what the value means

the argument_name of a row of this arm, presented on graphitron_argument_reference_step_target.argument_name, whose comment carries what the value means

the ordinal of a row of this arm, presented on graphitron_argument_reference_step_target.ordinal, whose comment carries what the value means

the position of a row of this arm, presented on graphitron_argument_reference_step_target.position, whose comment carries what the value means

the via of a row of this arm, presented on graphitron_argument_reference_step_target.via, whose comment carries what the value means

the key_matched_by of a row of this arm, presented on graphitron_argument_reference_step_target.key_matched_by, whose comment carries what the value means

the from_source_name of a row of this arm, presented on graphitron_argument_reference_step_target.from_source_name, whose comment carries what the value means

the from_schema of a row of this arm, presented on graphitron_argument_reference_step_target.from_schema, whose comment carries what the value means

the from_table of a row of this arm, presented on graphitron_argument_reference_step_target.from_table, whose comment carries what the value means

the to_source_name of a row of this arm, presented on graphitron_argument_reference_step_target.to_source_name, whose comment carries what the value means

the to_schema of a row of this arm, presented on graphitron_argument_reference_step_target.to_schema, whose comment carries what the value means

the to_table of a row of this arm, presented on graphitron_argument_reference_step_target.to_table, whose comment carries what the value means

the constraint_name of a row of this arm, presented on graphitron_argument_reference_step_target.constraint_name, whose comment carries what the value means

the fk_on_from of a row of this arm, presented on graphitron_argument_reference_step_target.fk_on_from, whose comment carries what the value means

the targets of a row of this arm, presented on graphitron_argument_reference_step_target.targets, whose comment carries what the value means

the candidates of a row of this arm, presented on graphitron_argument_reference_step_target.candidates, whose comment carries what the value means

the graph_name of a row of this arm, presented on graphitron_argument_reference_step_target.graph_name, whose comment carries what the value means

the type_name of a row of this arm, presented on graphitron_argument_reference_step_target.type_name, whose comment carries what the value means

the field_name of a row of this arm, presented on graphitron_argument_reference_step_target.field_name, whose comment carries what the value means

the argument_name of a row of this arm, presented on graphitron_argument_reference_step_target.argument_name, whose comment carries what the value means

the ordinal of a row of this arm, presented on graphitron_argument_reference_step_target.ordinal, whose comment carries what the value means

the position of a row of this arm, presented on graphitron_argument_reference_step_target.position, whose comment carries what the value means

the via of a row of this arm, presented on graphitron_argument_reference_step_target.via, whose comment carries what the value means

the from_source_name of a row of this arm, presented on graphitron_argument_reference_step_target.from_source_name, whose comment carries what the value means

the from_schema of a row of this arm, presented on graphitron_argument_reference_step_target.from_schema, whose comment carries what the value means

the from_table of a row of this arm, presented on graphitron_argument_reference_step_target.from_table, whose comment carries what the value means

the to_source_name of a row of this arm, presented on graphitron_argument_reference_step_target.to_source_name, whose comment carries what the value means

the to_schema of a row of this arm, presented on graphitron_argument_reference_step_target.to_schema, whose comment carries what the value means

the to_table of a row of this arm, presented on graphitron_argument_reference_step_target.to_table, whose comment carries what the value means

the targets of a row of this arm, presented on graphitron_argument_reference_step_target.targets, whose comment carries what the value means

the candidates of a row of this arm, presented on graphitron_argument_reference_step_target.candidates, whose comment carries what the value means

the owning graph’s partition, carried from graphql_argument, which is the relation the fan-out drives from

the type owning the field the argument sits on

the field the argument sits on

the argument whose scope this row states; part of the grain with the table below, so two arguments of one field each get their own row and neither reader has to know they agree, and one argument of a multi-table polymorphic root gets one row per branch it binds against

which rule answered, carried unchanged from graphitron_field_scope_table, whose comment says what the four values mean. Every argument of one field carries the same value, and every branch of one argument does too, the rule being the field’s and not the argument’s or the branch’s; a reader wanting one of them filters on it and owns having chosen

the scope table’s catalog partition, the first column of the sql_table key this row names

the scope table’s SQL schema

the scope table’s SQL name; with the two columns above this is sql_table’s full key, so the table’s own columns and constraints are one join away

the graph_name of a row of this rule, which the stage inserts into graphitron_argument_scope_table.graph_name, whose comment carries what the value means

the type_name of a row of this rule, which the stage inserts into graphitron_argument_scope_table.type_name, whose comment carries what the value means

the field_name of a row of this rule, which the stage inserts into graphitron_argument_scope_table.field_name, whose comment carries what the value means

the argument_name of a row of this rule, which the stage inserts into graphitron_argument_scope_table.argument_name, whose comment carries what the value means

the basis of a row of this rule, which the stage inserts into graphitron_argument_scope_table.basis, whose comment carries what the value means

the table_source_name of a row of this rule, which the stage inserts into graphitron_argument_scope_table.table_source_name, whose comment carries what the value means

the table_schema of a row of this rule, which the stage inserts into graphitron_argument_scope_table.table_schema, whose comment carries what the value means

the table_name of a row of this rule, which the stage inserts into graphitron_argument_scope_table.table_name, whose comment carries what the value means

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the mapping was written in

source line of the string the mapping was written as, 1-based per the graphql-java convention

source column of the same. The four columns are that string’s key in graphql_ast_value_entry, which holds it verbatim, so the directive or reference it was written in is a join from here and the raw text is not repeated

the entry’s 0-based position in the mapping as written, completing the key; the order an author wrote the entries in

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; a mapping whose string went is swept with it

the parameter the entry names, as written: a Java parameter at a code reference, a routine parameter at @routine

what the entry binds the parameter to, as written: a dotted path into the arguments, or a sigil such as $session. Which sites admit a sigil is a rule about the site and not about the string, so nothing here judges it

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the reference was written in

source line of the node the reference was written as, 1-based per the graphql-java convention

source column of the same. The four columns are a graphql_ast_entry key: the ExternalCodeReference object value wherever one is written, and the @sourceRow application, so which directive and which argument wrote the reference are joins from here rather than columns

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; a reference whose node went is swept with that node

the class the reference names, as written. NOT NULL because a reference naming no class asserts nothing this relation can hold, and writes no row

the method the reference names, as written, or NULL where it names none. A default a site applies to an omitted method is a resolution and is not applied here

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_field_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the defaultFirstValue argument as written, or NULL where the author wrote none. The definition’s own default of 100 is not supplied here: it stands in graphql_directive_argument.default_value_sdl, and filling it in would lose the difference between a default taken and a value written. A bare @asConnection is therefore a row of two nulls, which is what says the directive was applied with nothing said

the connectionName argument as written, or NULL where the author wrote none. The argument is deprecated and the deprecation is the directive definition’s to state; a transcription records the value and says nothing about whether it should have been written

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_field_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the index argument as written, naming a database index, or NULL where none was

the primaryKey argument as written, or NULL where none was. The directive admits exactly one of index, fields and primaryKey, and no constraint here states that: an application stating two is a document this relation transcribes and a detection reports

the direction argument as the author spelled it, the token kept as its own text and never checked against the vocabulary the definition declares. It is the directive-level fallback each child row’s own direction overrides

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here. The index that join reads is dense: FieldSort is the element type the directive definition declares, so an element of some other shape makes the whole application one the definition does not admit and none of it is transcribed

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; an element whose whole application went is swept with the row it hangs on

the name field of the element as written, naming a column of the jOOQ table. NOT NULL because FieldSort declares name as String!, so an element without one is not a FieldSort and its application is not transcribed; the constraint is the directive definition, enforced

the collate field of the same, as written, or NULL where none was; a collation name is database-specific and resolves against nothing here

the direction field of the same, as the author spelled it, or NULL where none was. A NULL is what says the element takes the directive-level direction, so nothing is filled in for it here

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_type_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the on argument decoded to the string the author wrote. NOT NULL because the definition requires the argument, so an application without it is refused before a decode sees it. Whether the database has a column of that name is a question for a resolution and not for this row

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_type_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the value argument decoded to the string the author wrote. NOT NULL because the definition requires the argument, so an application without it is refused before a decode sees it. Always a string here whatever the column’s SQL type, the comparison being the resolution’s to make

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_type_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the className field of the reference, as written. The identity of the fact this row states, so an application naming no class writes no row rather than a row nothing identifies

the method field of the reference, as written, or NULL where none was

the argMapping field of the reference, as written, or NULL where none was. Kept as the one string the author typed; what its segments name is a question for the argument-mapping derivation

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_enum_value_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the name argument decoded to the string the author wrote. Whether a column of that name exists is the anchor’s question and not this row’s

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; a handler whose whole application went is swept with the directive row it hangs on

the vendor error code this handler matches on, as written, or NULL where none was

the standard SQL state this handler matches on, as written, or NULL where the vendor code was used instead. The two are alternative spellings of one assertion rather than two facts, which is why they share a relation and a CHECK refuses a handler carrying both

a substring the exception message must contain, as written, or NULL where the handler takes every SQLException it discriminates to

the client-facing message this handler returns, as written, or NULL where the exception’s own message is used

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; a handler whose whole application went is swept with the directive row it hangs on

the exception class this handler matches on, as written. A GENERIC handler matches by class identity, so a handler naming none states nothing and writes no row

a substring the exception message must contain, as written, or NULL where the handler takes every exception of the class

the client-facing message this handler returns, as written, or NULL where the exception’s own message is used

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; a handler whose whole application went is swept with the directive row it hangs on

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_field_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the className field of the reference, as written

the method field of the same, as written, or NULL where none was

the argMapping field of the same, kept as the one string the author typed

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same, so this row is the decode of exactly one row of graphql_ast_type_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the fields argument as the author typed it, kept whole beside the selections it parsed into. The parse is a reading and this is what was read, so a reader wanting to re-emit the directive takes this column and a reader wanting its structure takes the rows below

the resolvable argument decoded to the boolean the author wrote, or NULL where they wrote none. NULL rather than true, the directive’s declared default being a generator constant and not a fact about the document

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same, so the four together name the application whose field set was parsed

which selection of the parse this segment belongs to

the depth of this segment within that selection, zero being the outermost. Nesting survives the parse as segments rather than being rendered back into a dotted name a reader would take apart again

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the field this segment names, as the grammar cut it. Whether the type declares such a field is a question for a resolution and not for this row

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same, so the four together name the application whose field set was parsed

the index of this selection in the field set, counting leaves in written order. The grammar yields a list and a relation holds a set, so the order is a column; a decoded element that is a node the author wrote needs none, being identified by the position it was written at

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_field_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the name argument exactly as written. Nullable although the definition marks it required, because a document that omits it still applied the directive and the row is what says so. What the name refers to, a column or a Java member, is settled by what backs the field and is not this relation’s business

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; an element whose whole application went is swept with the directive row it hangs on

the element as written. NOT NULL because an element the author wrote as anything but a string contributes no row at all, so a name is the whole of what a row here says; the element it skipped stands verbatim in graphql_ast_applied_argument_entry. Whether the runtime context carries a value under this name is nothing any reading of a document can say

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_field_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the className field of the reference, as written

the method field of the same, as written, or NULL where none was

the argMapping field of the same, kept as the one string the author typed. What its segments name is a question for the argument-mapping derivation, which is where the grammar that cuts it lives

the override argument as written, or NULL where the author wrote none. The definition’s own default is not supplied here: what an omitted argument falls back to stands in graphql_directive_argument.default_value_sdl, and filling it in would lose the difference between a default taken and a value written

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_field_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the typeName argument as written, or NULL on a bare @nodeId. Nothing here supplies what an omitted name deduces to, the containing type on a plain field and the table’s node type on a referenced one: both are resolutions over other relations, and a row of NULL is what says the author left the deduction to the build

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; an element whose whole application went is swept with the directive row it hangs on

the className of the element’s condition reference, as written. NOT NULL because a row exists exactly where the author stated a condition, which is the one arm of an element that reaches the classpath rather than the catalog

the method of the same, as written, or NULL where none was

the argMapping of the same, kept as the one string the author typed; what its segments name is a question for the argument-mapping derivation

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; an element whose whole application went is swept with the row it hangs on

the className of the element’s condition reference, as written. NOT NULL because a row exists exactly where the author stated a condition. The manual admits one on an output coordinate only, which is a rule about where the application sits and so a detection over these rows rather than a constraint this relation states

the method of the same, as written, or NULL where none was

the argMapping of the same, kept as the one string the author typed

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_field_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the type argument exactly as written, naming the participant this path applies to. Nullable although the definition marks it required, because a document that omits it still applied the directive. Two applications naming one participant are two rows here and the conflict is a detection over them, this relation refusing nothing

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; an element whose whole application went is swept with the row it hangs on

the key field of the element as written, naming a foreign-key constraint. NOT NULL because a row exists exactly where the author named one

the schema half of the written name, which scopes the lookup to constraints held in that schema; NULL where none was written

the constraint half of the same, total because the grammar always yields one where a name was written

the upper-cased form of the column beside it, for the case-insensitive match against sql_constraint’s table_schema_upper, a written qualifier naming the schema of the table holding the constraint rather than a namespace of the constraint’s own. Generated, so nothing writes it and nothing can. NULL where the column beside it is, which is an unqualified spelling and matches on its name half alone

the upper-cased form of the column beside it, for the case-insensitive match against sql_constraint’s constraint_name_upper and jooq_name_upper, in that precedence. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; an element whose whole application went is swept with the row it hangs on

the table field of the element as written. NOT NULL because a row exists exactly where the author named a table, which is what this relation says

the schema half of the written name, or NULL where none was written; split by QualifiedNameGrammar, which only cuts the string

the table half of the same, total because the grammar always yields one where a name was written

the upper-cased form of the column beside it, for the case-insensitive match against sql_table’s table_schema_upper. Generated, so nothing writes it and nothing can. NULL where the column beside it is, which is an unqualified spelling and is admitted against any schema the graph’s sources carry

the upper-cased form of the column beside it, for the case-insensitive match against sql_table’s table_name_upper. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; an element whose whole application went is swept with the directive row it hangs on

the key field of the element as written, naming a foreign-key constraint. NOT NULL because a row exists exactly where the author named one

the schema half of the written name, which scopes the lookup to constraints held in that schema; NULL where none was written

the constraint half of the same, total because the grammar always yields one where a name was written

the upper-cased form of the column beside it, for the case-insensitive match against sql_constraint’s table_schema_upper, a written qualifier naming the schema of the table holding the constraint rather than a namespace of the constraint’s own. Generated, so nothing writes it and nothing can. NULL where the column beside it is, which is an unqualified spelling and matches on its name half alone

the upper-cased form of the column beside it, for the case-insensitive match against sql_constraint’s constraint_name_upper and jooq_name_upper, in that precedence. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; an element whose whole application went is swept with the directive row it hangs on

the table field of the element as written. NOT NULL because a row exists exactly where the author named a table, which is what this relation says

the schema half of the written name, or NULL where none was written; split by QualifiedNameGrammar, which only cuts the string

the table half of the same, total because the grammar always yields one where a name was written

the upper-cased form of the column beside it, for the case-insensitive match against sql_table’s table_schema_upper. Generated, so nothing writes it and nothing can. NULL where the column beside it is, which is an unqualified spelling and is admitted against any schema the graph’s sources carry

the upper-cased form of the column beside it, for the case-insensitive match against sql_table’s table_name_upper. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_enum_value_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the name argument decoded to the string the author wrote. NOT NULL because it is the only argument the directive has, so an application without it would give a row carrying its key and nothing else, which is what the applied-directive row already says

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_input_value_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the name argument exactly as written. The definition requires it, so an application that omits it is malformed rather than meaning anything, and it writes no row here at all: the applied-directive row says the directive was applied and the argument’s own value says what was written instead

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; an entry whose whole application went is swept with the decode it hangs on

the context key as written. Not nullable, unlike the payload of a decode: an element written as some other shape contributes no row at all rather than a row of NULL, so what stands here is always something the author typed

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_input_value_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the className field of the condition reference, as written. The class the anchor joins the classpath census on, so an application naming none writes no row rather than a row nothing can be resolved from

the method field of the same, as written, or NULL where none was

the argMapping field of the same, as written, or NULL where none was. Kept as the one string the author typed; what its segments name is a question for the argument-mapping derivation

the override argument as written, or NULL where the author wrote none. The definition’s default of false is not filled in here: it stands in graphql_directive_argument.default_value_sdl, and writing it would lose the difference between a default taken and a value written

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_input_value_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the reason argument decoded to the string the author wrote, or NULL where they wrote none or wrote something that is not a string. The decode is the whole reason this relation exists beside the applied-argument row: that row carries the rendered literal, quotes included, and a consumer wanting the text would have to re-read SDL to get it

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_input_value_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the typeName argument as written, naming the type the identifier belongs to. A bare @nodeId writes no row: the author is asking for the deduction, which sends the anchor to a different join entirely, and the absence of a row here is what says so

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; an element whose whole application went is swept with the row it hangs on

the className of the element’s condition reference, as written

the method of the same, as written, or NULL where none was; an optional narrowing rather than a different intent

the argMapping of the same, as written, or NULL where none was. Kept as the one string the author typed; what its segments name is a question for the argument-mapping derivation

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; an element whose whole application went is swept with the row it hangs on

the className of the element’s condition reference, as written

the method of the same, as written, or NULL where none was; an optional narrowing rather than a different intent

the argMapping of the same, as written, or NULL where none was. Kept as the one string the author typed; what its segments name is a question for the argument-mapping derivation

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_input_value_directive_entry; the directive is repeatable and no ordinal is needed, each application standing at its own at sign

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the type argument exactly as written, naming the participant this path applies to. Required by the definition, so an application omitting it writes no row; whether the name is a participant of any consuming query is a question for the resolving

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; an element whose whole application went is swept with the row it hangs on

the key field of the element exactly as written, naming the foreign-key constraint the hop is drawn through

the schema half of the written key name, or NULL where none was written; the qualifier binds the constraint holder’s schema

the constraint half of the same, which is what sql_constraint is matched on

the upper-cased form of the column beside it, for the case-insensitive match against sql_constraint’s table_schema_upper, a written qualifier naming the schema of the table holding the constraint rather than a namespace of the constraint’s own. Generated, so nothing writes it and nothing can. NULL where the column beside it is, which is an unqualified spelling and matches on its name half alone

the upper-cased form of the column beside it, for the case-insensitive match against sql_constraint’s constraint_name_upper and jooq_name_upper, in that precedence. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; an element whose whole application went is swept with the row it hangs on

the table field of the element exactly as written

the schema half of the written table name, or NULL where none was written; split by QualifiedNameGrammar, which only cuts the string

the table half of the same, which is what the spelled-table resolution is matched on

the upper-cased form of the column beside it, for the case-insensitive match against sql_table’s table_schema_upper. Generated, so nothing writes it and nothing can. NULL where the column beside it is, which is an unqualified spelling and is admitted against any schema the graph’s sources carry

the upper-cased form of the column beside it, for the case-insensitive match against sql_table’s table_name_upper. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; an element whose whole application went is swept with the row it hangs on

the key field of the element exactly as written, naming the foreign-key constraint the hop is drawn through

the schema half of the written key name, or NULL where none was written; the qualifier binds the constraint holder’s schema

the constraint half of the same, which is what sql_constraint is matched on

the upper-cased form of the column beside it, for the case-insensitive match against sql_constraint’s table_schema_upper, a written qualifier naming the schema of the table holding the constraint rather than a namespace of the constraint’s own. Generated, so nothing writes it and nothing can. NULL where the column beside it is, which is an unqualified spelling and matches on its name half alone

the upper-cased form of the column beside it, for the case-insensitive match against sql_constraint’s constraint_name_upper and jooq_name_upper, in that precedence. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; an element whose whole application went is swept with the row it hangs on

the table field of the element exactly as written

the schema half of the written table name, or NULL where none was written; split by QualifiedNameGrammar, which only cuts the string

the table half of the same, which is what the spelled-table resolution is matched on

the upper-cased form of the column beside it, for the case-insensitive match against sql_table’s table_schema_upper. Generated, so nothing writes it and nothing can. NULL where the column beside it is, which is an unqualified spelling and is admitted against any schema the graph’s sources carry

the upper-cased form of the column beside it, for the case-insensitive match against sql_table’s table_name_upper. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_schema_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the url argument decoded to the string the author wrote, or NULL where they wrote none or wrote something that is not a string. Nothing here reads the specification it names, and no version is parsed out of it

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the name the element imports, taken from the element itself where it was written as a bare string and from its name field where it was written as an object. NOT NULL because it is the element’s whole identity: an element that named nothing imports nothing, and the applied-directive row already says the @link was applied

the local name the element binds the import to, from an object element’s as field, NULL on a bare string and on an object that wrote none. NULL is the fact that the import keeps its own name rather than a default filled in here

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_field_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the typeName argument as the author spelled it, an enum token being kept as its own text and never checked against the vocabulary the definition declares. Nothing upstream has validated it, so a CHECK here would turn a typo into a constraint violation; membership is a detection

the multiRow argument as written, or NULL where the author wrote none; the definition’s own default of false stands in graphql_directive_argument.default_value_sdl rather than being filled in here

the table argument as written, or NULL where none was; what an omitted table resolves to is a resolution and not this relation’s business

the schema half of the written name, or NULL where none was written; split by QualifiedNameGrammar, which only cuts the string

the table half of the same

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_type_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the typeId argument decoded to the string the author wrote, or NULL where they wrote none or wrote something that is not a string. NULL is the fact that the author left it out, which the directive documents as meaning the type’s own name; substituting the name here would lose which of the two they wrote

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line the element was written at, 1-based per the graphql-java convention

source column of the same. The four key columns are the element’s own position, so this row is the decode of exactly one row of graphql_ast_value_entry; which application holds it, and where in the list it sits, are that row’s to say

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the column the element names, as the author spelled it. Whether the database has a column of that name, and whether the columns together are a key, are questions for a resolution and not for this row

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_enum_value_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the index argument decoded to the string the author wrote, or NULL where they wrote none or wrote something that is not a string

the primaryKey argument decoded to the boolean the author wrote, or NULL where they wrote none. NULL rather than false, the directive’s own default being a generator constant and not a fact about the document

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the element’s name field decoded to the string the author wrote, or NULL where they wrote none or wrote something that is not a string

the element’s collate field on the same terms. A database-specific collation name, resolving against nothing here

the element’s direction field as the enum token the author wrote, or NULL where they wrote none

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_field_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the on argument as written, naming the column whose distinct values name the generated fields. Nullable although the definition marks it required, because a document that omits it still applied the directive

the value argument as written, naming the column each generated field reads

the vocabulary argument as written, naming the GraphQL enum whose values fix the vocabulary, or NULL where none was

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. With the line and the file, the application whose string this pair came out of

the pair’s 0-based index in the string the grammar read. A pair is written inside a string rather than as a node, so it has no position of its own to be identified by and takes its index instead; that is the whole of what this column is

when the reading that produced this row ran. The reading finishes by deleting the rows of this file carrying an older instant, which are the pairs an author removed from a string that still stands; an application the author moved is swept with the routine row it hangs on

the routine parameter the pair binds, as written and resolved against nothing

the column the pair binds it to, as written. A dotted spelling is kept whole here and rejected by detection rather than split, the grammar admitting what the author typed and the verdict belonging to a reader of these rows

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_field_directive_entry, and the ordinal the anchors give a repeated @routine is not a column here: the position the application was written at is what tells two of them apart

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the name argument exactly as written, optionally schema-qualified. Nullable although the definition marks it required, because a document that omits it still applied the directive

the schema half of the written name, or NULL where none was written; split by QualifiedNameGrammar, which only cuts the string

the routine half of the same

the argMapping argument, kept as the one string the author typed; what its segments name is a question for the argument-mapping derivation

the columnMapping argument, kept the same way. It shares argMapping’s grammar and not its subject, binding a routine parameter to a column of the previous chain node rather than to an input path, which is why the two are columns beside each other rather than one

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_type_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the scalar argument exactly as written. Required by the definition, so an application omitting it asserts nothing and writes no row; the applied-directive row says it was applied and the argument’s own value says what was written instead

the class half of the written constant, or NULL where the string does not split; ConstantReferenceGrammar only cuts it

the field half of the same

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the element was written in

source line of the element this row decodes, 1-based per the graphql-java convention

source column of the same. The four columns are the element’s own key in graphql_ast_value_entry, so the list it sits in, the index it was written at and the application holding it are one join away rather than columns here

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant; an element whose whole application went is swept with the row it hangs on

the element as written. NOT NULL because an element the author wrote as anything but a string contributes no row at all, so a name is the whole of what a row here says; the element it skipped stands verbatim in graphql_ast_applied_argument_entry. Whether the runtime context carries a value under this name is nothing any reading of a document can say

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_field_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the className field of the reference, as written

the method field of the same, as written, or NULL where none was

the argMapping field of the same, kept as the one string the author typed. This is the one site whose mapping admits a runtime sigil on the right-hand side, and that is a fact about how the string is later cut rather than about the string: the whole of it stands here as typed, and the lexing that tells a sigil from a path belongs where the segments are read

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_field_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the className argument as written. Two flat arguments rather than one object literal, which is the directive’s own shape: this site names a class and a method directly where the others nest them inside an ExternalCodeReference

the method argument as written

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the application was written in

source line of the at sign, 1-based per the graphql-java convention

source column of the same. The four key columns are the applied directive’s own key, so this row is the decode of exactly one row of graphql_ast_type_directive_entry and neither carries what the other holds

when the reading that produced this row ran. The reading finishes by deleting its file’s rows carrying an older instant, which are the applications the author removed or renamed in place; an application the author moved is swept with the directive row it hangs on

the name argument exactly as written. A bare @table writes no row: the author is asking for the table name to be deduced from the type’s own, which is a thing they said and which the absence of a row here is what records

the schema half of the written name, or NULL where none was written; split by QualifiedNameGrammar, which only cuts the string

the table half of the same

the upper-cased form of the column beside it, for the case-insensitive match against sql_table’s table_schema_upper. Generated, so nothing writes it and nothing can. NULL where the column beside it is, which is an unqualified spelling and is admitted against any schema the graph’s sources carry

the upper-cased form of the column beside it, for the case-insensitive match against sql_table’s table_name_upper. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the owning graph’s partition, carried from the producing field

the payload type the producing field returns; the type whose data channels these rows are

the data channel’s field name within the payload type; the coordinate an author’s cursor sits on

which producing directive returns the payload, a closed three-value domain: SERVICE (@service), DML (@mutation), ROUTINE (@routine). Provenance and policy both, the two rejections that differ between families being this column’s; a payload two families return is a row per family, and a reader that means one of them filters on it

what the channel’s element is, a closed three-value domain: TABLE (the named type is bound to one catalog table), RECORD (the backing closure reaches a class for it), ID (the ID scalar, the encoded-key echo). Never NULL here, an unrecognized element having dropped its whole payload

how many data channels the payload declares, this row being one of them; 1 is what a carrier requires, and a larger number is what the generator’s own "require exactly one" rejection counts. Stated as a column rather than left to each reader’s count, because whether the payload is a carrier at all decides the reading and a reader that counted for itself would be re-deriving the scan’s arity

the graph_name of a row of this rule, which the stage inserts into graphitron_carrier_data_field.graph_name, whose comment carries what the value means

the type_name of a row of this rule, which the stage inserts into graphitron_carrier_data_field.type_name, whose comment carries what the value means

the field_name of a row of this rule, which the stage inserts into graphitron_carrier_data_field.field_name, whose comment carries what the value means

the family of a row of this rule, which the stage inserts into graphitron_carrier_data_field.family, whose comment carries what the value means

the element_kind of a row of this rule, which the stage inserts into graphitron_carrier_data_field.element_kind, whose comment carries what the value means

the data_fields of a row of this rule, which the stage inserts into graphitron_carrier_data_field.data_fields, whose comment carries what the value means

the owning graph’s partition, carried from the facet

the type declaring the carrier

the carrier field

the connection this carrier mints, which the container is named from

the per-connection container type, which is the connection’s name and a suffix

the facet’s position on the container, dense per carrier and in emission order

the facet’s field on the container, which is the @asFacet site’s own name

the bucket type for this facet’s values, whose name carries the scalar and whether a null value is a bucket

the scalar the facet’s values are, which the bucket’s own value field returns

whether a null is one of the buckets, which decides both the bucket type’s name and its value field’s nullability

the owning graph’s partition, carried from the written reference

the file the reference was written in, the first of the four columns that are the written reference’s key in graphitron_ast_code_reference_entry

source line of the node the reference was written as

source column of the same, completing the key. One reference resolves to at most one method, so the reference is the whole grain

the classpath entry the resolved method was read from, the first of the four columns naming one code_method row; one of the entries the graph reached through store_graph_source

the class declaring the resolved method, equal to what the author wrote, the match being exact: Java names are case-sensitive and a misspelling resolves to nothing rather than to a near match

the resolved method’s name: the reference’s, or the field’s where an @externalField wrote none, as graphitron_code_reference_site states it

the resolved method’s JVM descriptor, completing the reference into code_method. Not in the key: a reference matching two overloads is ambiguous and draws no row, so the descriptor is what the one method is rather than what tells two rows apart

when the reading that derived this row ran. Swept per graph after the reading upserts, so a reference that stopped resolving leaves and the rest stay; a reference the author removed goes through the cascade on its written form

the owning graph’s partition, carried from the written reference

the file the reference was written in, the first of the four columns that are the written reference’s key

source line of the node the reference was written as

source column of the same, completing the key

the directive whose application wrote the reference, reached through the argument that holds it, or the application itself at @sourceRow

the element the application is written on, as graphql_ast_element_entry spells it: a type, a field, an argument or an input field

the type owning that element where the element is a field or an argument, NULL where it is a type

the field that element is or belongs to, NULL where it is a type

the class the reference names, as written

the method the reference names: as written, or the field’s own name where an @externalField wrote none, which is the one default any site applies. NULL where the reference names a class only, as @enum does

the owning graph’s partition, carried from whichever reference-step relation named the pair; the leading key dimension that keeps one workspace’s graphs apart

the condition class as the author wrote it, fully qualified, carried from the path element; the key this route answers for together with the method beside it

the condition method name as the author wrote it. A name and not a signature: the generator resolves by name and admits the declarations that share it, so this relation answers for the set. Overloads differing on the departure slot are several routes here and the hop arities are where that shows; overloads differing on the arrival slot are no route, the arrival being the one thing the set must agree on

the departing table’s catalog partition, first column of its sql_table key

the departing table’s SQL schema

the departing table’s SQL name; a candidate departure and never a fact about a chain, on graphitron_field_reference_step_hop.from_table’s terms. Where parameter 0 names a generated table class this is that one table; where it names none the candidacy is every table in the graph’s sources, which costs nothing until a chain says where it actually stands

the arriving table’s catalog partition, first column of its sql_table key

the arriving table’s SQL schema

the arriving table’s SQL name. With the two columns above this is sql_table’s full key. Always a table parameter 1 names concretely, never a candidacy: a route with no certain arrival is no route

the owning graph’s partition, carried from the application

the type declaring the carrier

the carrier field itself

the carrier’s coordinate, spelled as graphitron_element spells one

the connection type this carrier mints: what @asConnection(connectionName:) asked for, or the default built from the carrier’s own coordinate. Two carriers may land on one name, which is a disagreement the anchor resolves rather than a key this relation holds

the edge type, which is the connection’s name and a suffix; derived here so no arm spells the rule a second time

the carrier’s element type, wrappers stripped: what the connection pages over

that element as the machinery fields write it, carrying the item nullability the author gave the list

whether the list’s items are non-null, which the machinery fields carry into the shapes they mint

whether the carrier itself is non-null, which the rewritten field keeps

the carrier’s position on its type, which the rewrite does not change

the carrier’s docstring, carried across the rewrite unchanged

the page size @asConnection asked for, or NULL where it asked for none

how many arguments the author wrote on the carrier, which is where the minted pagination arguments start numbering; they follow the authored ones rather than displacing them

the document the application was written in, carried so a reader can say which application minted a name

the application’s line, on source_name’s terms

the application’s column, on source_name’s terms

the owning graph’s partition, carried from the connection type’s own row; the leading key dimension that keeps one workspace’s graphs apart

the connection type itself, the wrapper a field returns; with the graph, the grain

the type the connection paginates, read off the edge type’s node field’s named type with its wrappers already stripped by graphql_field. A name and not a binding: whether the element is bound to a table is graphitron_resolved_type_binding’s answer and deliberately not asked here

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the SDL file the row was captured from

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

as written; NULL when omitted

the deprecated shared-type override, as written; honoured by the expansion, deprecation is a lint detection

when the reading that derived this row ran. The reading finishes by deleting this graph’s rows carrying a different instant, which are the applications an author removed from a coordinate that still stands; a coordinate the author removed takes its rows with it through the cascade on the reference below, so the two together are what makes this relation total without a pass emptying it first

the owning graph’s partition, carried from the carrier’s arguments

the type owning the carrier field

the carrier field’s name within that type; with the column above, the connection carrier’s coordinate

the facet’s place in this carrier’s facet list, 1-based and dense: argument declaration order, then facet field declaration order. The emission order, so a consumer reads it rather than re-deriving it from the two ordinals it was computed from

the carrier argument the facet’s binding rides in. Half of a facet’s suppression identity at emission: a same-named field on a sibling filter argument is a different binding, and the pair with facet_field_name is what tells them apart

witness: the input object type the application was written on, which is the argument’s named type. With the column beside it this is graphitron_facet_binding’s key, so the application’s own position is one join away

the facet field’s name: the label the counts surface under, and the other half of the suppression identity

the column the counts group by, carried from graphitron_facet_binding

the named type a facet key carries, carried from graphitron_facet_binding

whether a facet key may be null, carried from graphitron_facet_binding

the @asFacet application’s own file, carried from graphitron_facet_binding: a diagnostic about a facet points at the application and not at the carrier that consumes it

source line of the application, 1-based

source column of the application, 1-based

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the SDL file the row was captured from

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

the database index name as written

as written; NULL when omitted

as written; open column, the ASC default is a derivation

when the reading that derived this row ran. The reading finishes by deleting this graph’s rows carrying a different instant, which are the applications an author removed from a coordinate that still stands; a coordinate the author removed takes its rows with it through the cascade on the reference below, so the two together are what makes this relation total without a pass emptying it first

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

0-based position within the owning list

the name argument as written

the collation as written, when declared

the sort direction as written; author-spelled enum literal, open column

when the reading that derived this row ran. The reading finishes by deleting this graph’s rows carrying a different instant, which are the applications an author removed from a coordinate that still stands; a coordinate the author removed takes its rows with it through the cascade on the reference below, so the two together are what makes this relation total without a pass emptying it first

the defect’s name, and the whole key. Declared here rather than captured, so it carries no graph and no instant: the vocabulary is a property of this generator and not of anybody’s schema

whether a build stops on it, stated once per defect rather than once per row. A function of the code and nothing else, which is why it lives beside the code and not on the findings

whose problem it is: AUTHOR where changing the schema removes the defect, GENERATOR where the schema is legitimate and this generator has no emitter for the shape. A function of the code exactly as the severity is, which is why it sits here; a code whose fault depended on the row would be two codes, and splitting it is what tells an author to edit from what tells them to wait

the diagnostic code an editor shows and filters by, null where none is published. The one part of a defect’s name a consumer reads as data rather than as prose, which is what keeps the code column load-bearing rather than a label

the rule, as one author-facing sentence. The message a consumer renders quotes this and the finding’s detail; neither is stored per row

the owning graph’s partition, anchored by store_graph

the element that was deprecated, in the specification’s grammar. No foreign key into graphql_element, and the reason is a producer rather than the model: that relation still has two writers, and the older one predates the two directive coordinate kinds, so a row here naming a retired directive would resolve under one producer and dangle under the other. The key becomes a reference the day the second writer goes. One relation rather than three, which is what a coordinate buys: this was a relation per shape of key, a directive under its name, an argument of one under two names, an input field under a type and a field, each carrying the same reason under a differently spelled key. A reader asking whether something is deprecated asks once and does not sort out which of three relations to ask

the replacement hint, as the author wrote it. Empty where the marker carried none, which is a marker without advice rather than no marker: absence of a row is what says a thing is not deprecated. Which of the two markers said so is not recorded and not asked. GraphQL forces them apart, the native marker being illegal on a directive definition, so a retired directive says so with a token in its description instead; unifying the two is what this family is for

when the reading that derived this row ran, on graphql_element.touched_at’s terms: swept per graph, and NOT NULL so the sweep is total

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the coordinate itself, in the specification’s own grammar and spelled exactly as graphql_element spells it: Type for a named type, Type.field for a field or an input field of one, and Type.field(argument:) for an argument of a field. Total by construction, which is what lets one column stand for a coordinate of any kind where the decomposed keys beside it cannot

which kind of schema element this row is, in the specification’s own vocabulary, and so which relation beside this one a reader joins to get the parts, FIELD and INPUT_FIELD sharing one. Four of the specification’s seven kinds, the vocabulary being narrower than graphql_element’s by exactly the enum value this family holds no anchor for

the reading that last wrote this row, which is what its sweep tells readings apart by: a row this reading did not rewrite is one the corpus stopped stating and goes. The other half of the lifecycle the walk’s clear used to stand in for, the cascade above being the first

the owning graph’s partition, carried from the transcription

the coordinate itself, as graphql_element spells it

the kind, in the specification’s own vocabulary and narrowed to the four this family anchors

the owning graph’s partition, carried from the minting row

the argument’s coordinate, Type.field(argument:) in the specification’s grammar, the trailing colon included because the specification writes it

always FIELD_ARGUMENT

the owning graph’s partition, carried from the minting row

the field’s coordinate, Type.field in the specification’s grammar

always FIELD; no macro today puts a field into an input object, and the day one does this is where the kind starts being derived

the owning graph’s partition, carried from the minting row

the minted type’s name, which is how the specification spells a named type’s coordinate

always NAMED_TYPE, the macros minting nothing else at this grain

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the file the offending directive was written in, the first of the three columns naming its position

the offending directive’s source line, 1-based per the graphql-java convention

the offending directive’s source column; with the two columns above, the entry this defect is about. The key is the entry and not the coordinate, because a coordinate is an aggregate over the sites that declare it and two offending applications at one coordinate are two things to fix

which defect, a graphitron_defect_type key and a foreign key into it. With the entry the whole key: one entry may break two rules and then carries two rows, there being no ranking here and nothing to choose between them

the type owning the coordinate the offending directive was written at. Payload and not key: an entry is written at one coordinate, so this is determined by the position beside it

the field of that type, NULL where the defect sits at a type rather than a field

the specific a rendered message quotes back, null where the code says everything

the owning graph’s partition, carried from the entry; the leading key dimension that keeps one workspace’s graphs apart

the file the offending directive was written in, the first of the three columns naming its position; with them a reference into graphql_ast_entry, which is the supertype that makes a @routine application and a path element the same kind of thing to point at

the offending directive’s source line, 1-based per the graphql-java convention

the offending directive’s source column; with the two columns above, the entry this defect is about. The key is the entry and not the coordinate, because a coordinate is an aggregate over the sites that declare it and two offending applications at one coordinate are two things to fix

which defect, a graphitron_defect_type key. With the entry the whole key: one entry may break two rules and then carries two rows, there being no ranking here and nothing to choose between them

the type owning the coordinate the offending directive was written at. Payload and not key: an entry is written at one coordinate, so this is determined by the position beside it and adds no way to tell two rows apart. Carried because the read surface this feeds groups by coordinate, and a class of rows answering NULL there is an axis with a hole in it rather than an axis

the field of that type, NULL where the defect sits at a type rather than a field. Every rule here is about a field today and the column is nullable anyway, the coordinate axis it feeds being nullable at the type grain by construction

the specific a rendered message quotes back, null where the code says everything. One column and never a payload: what a consumer needs beyond this is a join from the entry, and the columns that used to differ per defect were all message material

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

half of the site FK, so NOT NULL; a graphitron application always has an SDL position

line of the contributing declaration site, keyed with source_name

column of the contributing declaration site, the site key’s fourth part

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

0-based position within the owning list

GENERIC / DATABASE / VALIDATION as written; open column

the exception class as written

the database error code the handler matches on

the SQL state code the handler matches on

a substring the exception message must contain

SDL description string, when the author wrote one

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the SDL file the row was captured from

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

the fully-qualified Java class name as written

the Java method name as written

the argMapping string as written; the pair child is its decode

when the reading that derived this row ran. The reading finishes by deleting this graph’s rows carrying a different instant, which are the applications an author removed from a coordinate that still stands; a coordinate the author removed takes its rows with it through the cascade on the reference below, so the two together are what makes this relation total without a pass emptying it first

the owning graph’s partition, carried from graphitron_facet_entry

the input object type the facet field is declared on

the facet field’s name within that input type; with the two columns above, the grain

the field’s declaration order within its input type, carried from graphql_field; the inner half of the order one carrier’s facets surface in

the @field(name:) binding as written: the column the counts group by. Which table it resolves on is the consuming carrier’s element binding and not a fact about the application, so it is not here

the named type a facet key carries, the filter field’s leaf; a scalar or an enum, an input object being a decline above

whether a facet key may be null: the list element’s nullability where the filter field is a list, TRUE otherwise. With value_type_name it decides both the synthesized FacetValue type the counts surface through and whether the aggregate scrubs a null key

the @asFacet application’s own file; the position a diagnostic would carry

source line of the application, 1-based

source column of the application, 1-based

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the SDL file the row was captured from

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

the reading that last wrote this row; what the anchor’s sweep compares against to delete the applications the corpus no longer makes

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

@key is repeatable; document order

the applying declaration site, which every row here has, the relation holding authored applications alone

line of the contributing declaration site, keyed with source_name

column of the contributing declaration site, the site key’s fourth part

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

the field-set literal as written

as written; NULL when omitted

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

capture-assigned position in document order

0-based within the field set

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the owning @key application’s ordinal

the owning selection’s 0-based position within the field set

0-based position of the segment within the selection, dense from zero; position zero names a field of the type the @key sits on, and each further position descends into the one before it

the segment itself, one name carrying no dot; what a reader would otherwise have recovered by splitting a path

the owning graph’s partition, carried from whichever arm supplied the row

the type owning the field, anchored by graphitron_type

the field’s name within the owning type; with the two columns above, the grain

this row as graphitron_element spells it, Type.field in the specification’s grammar; the join down from the supertype, on graphitron_type.coordinate’s terms

the field’s position within its type, merge-ordered across declaration sites exactly as graphql_field numbers it, and the order the macro wrote them in on a minted type

the type expression as the generator reads it: the authored literal on an ordinary field, and the macro’s rewrite where one happened

that expression’s named type with its list and non-null wrappers stripped, which is the column readers actually join on

whether the outermost wrapper is non-null

whether the expression is a list

whether a list’s item is non-null; NULL where the expression is not a list, which the CHECK holds

the default literal where the coordinate is an input field with one; display material, never a dimension

the docstring, authored or macro-written; display material, never a dimension

the owning graph’s partition, carried from the transcription

the type the field is declared on

the field’s own name

Type.field, the specification’s spelling, which is the join up to graphitron_element

where the author wrote it among the type’s fields, carried so the emitted schema keeps their order

the type expression as written, wrappers included

the name at the bottom of that expression

whether the outermost wrapper is non-null

whether the expression is a list

whether a list’s items are non-null, and nothing where it is not a list

the default as written, which an output field never has and an input field may; the one column the minted set cannot supply

the docstring the author wrote, or nothing

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the application’s own position, here and below

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

the name argument as written

the upper-cased form of the column beside it, for the case-insensitive match against sql_column’s column_name_upper and jooq_name_upper. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the reading that last wrote this row; what the anchor’s sweep compares against to delete the applications the corpus no longer makes

the owning graph’s partition; the leading key dimension that keeps one workspace’s graphs apart

the type owning the field the application sits on

the field the application sits on; with the two columns above, the coordinate whose chain this row is a step of

the application’s place in the written order, dense from 0 across every directive that contributes to the chain. The manual states the order is load-bearing and the decode relations cannot carry it: each numbers its own applications, so @reference#0, @routine#0 and @reference#1 are three ordinals in two relations with no relation between them. In the key, so two applications at one position are unwritable rather than merely unexpected

the coordinate the application was written on, which with the two columns after it is the reference into graphql_directive_application. Carried beside the type and field above rather than instead of them: those are this relation’s own grain, which its chain siblings key by, and this is how the application it points at is named. The cascade on that reference is this relation’s sweep, there being no instant here to mark

which directive this application is of, in graphql_directive’s spelling. Two contribute: @reference adds hops and @routine adds its result table as a node. @referenceFor does not, being one participant’s own path rather than the field’s chain, which is why it is a route of its own and not a step of this one

that directive’s own ordinal at this coordinate, which is the join down to the decode relation carrying what the application says. Unique with the coordinate and the directive name, so one application cannot occupy two positions, and a foreign key into graphql_directive_application, so a position cannot be minted for an application nobody wrote

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the type owning the field whose chain this link is part of

the field whose chain this link is part of; with the two columns above a reference into graphql_field_element, the authored population, a macro-minted field writing no chain of its own

the link’s place in the chain, numbered from zero without a hole. Ranked over the written order rather than copied from any directive’s own numbering, for two reasons that both bite. @routine and @reference each number their applications from zero independently, so neither ordinal can say which of the two was written first; and the entry stratum numbers a path element by its authored index, which skips an element it does not transcribe, where a chain wants its links counted. The order ranked over is the directive’s written position, then the element’s authored index inside it, and a field coordinate being declared once is what makes two positions comparable: every directive of one field is written in one file

the file the link was written in, the first of the three columns naming its written position; a reference into graphql_ast_entry, which is where a routine application and a path element are one kind of thing. Spelled the way every relation holding a written position spells one, graphql_ast_entry included; an element in this schema is a schema coordinate, which is what the first three columns of this row already carry

the link’s source line, 1-based per the graphql-java convention

the link’s source column; with the two columns above, the written position the link’s own facts are keyed by. A @routine link points at the FIELD_DIRECTIVE entry and a path element at the VALUE entry, and what each link joins on is those facts rather than anything carried here: this states that the chain has a link here and where to read it, and never what the link does

when the reading that derived this row ran, on graphql_element.touched_at’s terms: swept per graph, and NOT NULL so the sweep is total

the graph_name of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the type_name of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the field_name of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the target_source_name of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the target_schema of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the target_table of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the position of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the last_position of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the via of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the key_matched_by of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the constraint_source_name of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the constraint_schema of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the constraint_table of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the constraint_name of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the fk_on_from of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the from_source_name of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the from_schema of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the from_table of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the to_source_name of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the to_schema of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the to_table of one reading of a chain link, on graphitron_field_table_link’s terms for the column of that name

the owning graph’s partition, carried from the reading; the leading key dimension that keeps one workspace’s graphs apart

the type owning the field whose chain this reading is of

the field whose chain this reading is of

the catalog partition of the target this reading’s chain leads to, the first column of the graphitron_field_table row the walk was seeded from

the target’s SQL schema

the target’s SQL name. A field with several targets walks once per target, the departure a chain stands on being the enclosing binding rather than anything the element says

the link’s place in the chain, carried from graphitron_field_chain_link where the order is stated

which authored arm this reading takes, in graphitron_field_table_link’s vocabulary of five, whose comment argues each

which name the author’s key spelling matched, on graphitron_field_table_link’s terms; NULL off the KEY arm

the catalog partition of the referential constraint this reading joins through, the first of four columns naming it

the schema of the table the constraint is declared on

that table’s name, the constraint having no schema of its own

the constraint’s own name as the catalog spells it; NULL where the arm joins through no constraint

whether the departure is the side declaring the constraint; NULL exactly where no constraint answered

the catalog partition of the table this reading departs from, the first of three columns naming it

the departure’s SQL schema

the departure’s SQL name; NULL only where a @routine heads the chain, which departs from nowhere

the catalog partition of the table this reading arrives at, the first of three columns naming it

the arrival’s SQL schema

the arrival’s SQL name. Every arm states its arrival outright, which is what lets a reading be taken without knowing which reading the link before it took

whether the tail walk, from the target backwards, reached this reading. A reading it reaches could end the chain, which says nothing about whether the chain gets there

whether the head walk, from the field’s departure forwards, reached this reading. A reading reached by both lies on a chain that runs the whole way; one only the head reaches is where a broken chain got to

the graph_name of a row of this arm, presented on graphitron_field_chain_link_resolution.graph_name, whose comment carries what the value means

the type_name of a row of this arm, presented on graphitron_field_chain_link_resolution.type_name, whose comment carries what the value means

the field_name of a row of this arm, presented on graphitron_field_chain_link_resolution.field_name, whose comment carries what the value means

the target_source_name of a row of this arm, presented on graphitron_field_chain_link_resolution.target_source_name, whose comment carries what the value means

the target_schema of a row of this arm, presented on graphitron_field_chain_link_resolution.target_schema, whose comment carries what the value means

the target_table of a row of this arm, presented on graphitron_field_chain_link_resolution.target_table, whose comment carries what the value means

the position of a row of this arm, presented on graphitron_field_chain_link_resolution.position, whose comment carries what the value means

the via of a row of this arm, presented on graphitron_field_chain_link_resolution.via, whose comment carries what the value means

the key_matched_by of a row of this arm, presented on graphitron_field_chain_link_resolution.key_matched_by, whose comment carries what the value means

the constraint_source_name of a row of this arm, presented on graphitron_field_chain_link_resolution.constraint_source_name, whose comment carries what the value means

the constraint_schema of a row of this arm, presented on graphitron_field_chain_link_resolution.constraint_schema, whose comment carries what the value means

the constraint_table of a row of this arm, presented on graphitron_field_chain_link_resolution.constraint_table, whose comment carries what the value means

the constraint_name of a row of this arm, presented on graphitron_field_chain_link_resolution.constraint_name, whose comment carries what the value means

the fk_on_from of a row of this arm, presented on graphitron_field_chain_link_resolution.fk_on_from, whose comment carries what the value means

the from_source_name of a row of this arm, presented on graphitron_field_chain_link_resolution.from_source_name, whose comment carries what the value means

the from_schema of a row of this arm, presented on graphitron_field_chain_link_resolution.from_schema, whose comment carries what the value means

the from_table of a row of this arm, presented on graphitron_field_chain_link_resolution.from_table, whose comment carries what the value means

the to_source_name of a row of this arm, presented on graphitron_field_chain_link_resolution.to_source_name, whose comment carries what the value means

the to_schema of a row of this arm, presented on graphitron_field_chain_link_resolution.to_schema, whose comment carries what the value means

the to_table of a row of this arm, presented on graphitron_field_chain_link_resolution.to_table, whose comment carries what the value means

the reached_by_tail of a row of this arm, presented on graphitron_field_chain_link_resolution.reached_by_tail, whose comment carries what the value means

the reached_by_head of a row of this arm, presented on graphitron_field_chain_link_resolution.reached_by_head, whose comment carries what the value means

the capture instant that last wrote this row, the mark the stage sweeps against: a row the latest capture of its graph did not write again is one the corpus no longer has

the graph_name of a row of this arm, presented on graphitron_field_chain_link_resolution.graph_name, whose comment carries what the value means

the type_name of a row of this arm, presented on graphitron_field_chain_link_resolution.type_name, whose comment carries what the value means

the field_name of a row of this arm, presented on graphitron_field_chain_link_resolution.field_name, whose comment carries what the value means

the target_source_name of a row of this arm, presented on graphitron_field_chain_link_resolution.target_source_name, whose comment carries what the value means

the target_schema of a row of this arm, presented on graphitron_field_chain_link_resolution.target_schema, whose comment carries what the value means

the target_table of a row of this arm, presented on graphitron_field_chain_link_resolution.target_table, whose comment carries what the value means

the position of a row of this arm, presented on graphitron_field_chain_link_resolution.position, whose comment carries what the value means

the via of a row of this arm, presented on graphitron_field_chain_link_resolution.via, whose comment carries what the value means

the from_source_name of a row of this arm, presented on graphitron_field_chain_link_resolution.from_source_name, whose comment carries what the value means

the from_schema of a row of this arm, presented on graphitron_field_chain_link_resolution.from_schema, whose comment carries what the value means

the from_table of a row of this arm, presented on graphitron_field_chain_link_resolution.from_table, whose comment carries what the value means

the to_source_name of a row of this arm, presented on graphitron_field_chain_link_resolution.to_source_name, whose comment carries what the value means

the to_schema of a row of this arm, presented on graphitron_field_chain_link_resolution.to_schema, whose comment carries what the value means

the to_table of a row of this arm, presented on graphitron_field_chain_link_resolution.to_table, whose comment carries what the value means

the reached_by_tail of a row of this arm, presented on graphitron_field_chain_link_resolution.reached_by_tail, whose comment carries what the value means

the reached_by_head of a row of this arm, presented on graphitron_field_chain_link_resolution.reached_by_head, whose comment carries what the value means

the capture instant that last wrote this row, the mark the stage sweeps against: a row the latest capture of its graph did not write again is one the corpus no longer has

the graph_name of a row of this arm, presented on graphitron_field_chain_link_resolution.graph_name, whose comment carries what the value means

the type_name of a row of this arm, presented on graphitron_field_chain_link_resolution.type_name, whose comment carries what the value means

the field_name of a row of this arm, presented on graphitron_field_chain_link_resolution.field_name, whose comment carries what the value means

the target_source_name of a row of this arm, presented on graphitron_field_chain_link_resolution.target_source_name, whose comment carries what the value means

the target_schema of a row of this arm, presented on graphitron_field_chain_link_resolution.target_schema, whose comment carries what the value means

the target_table of a row of this arm, presented on graphitron_field_chain_link_resolution.target_table, whose comment carries what the value means

the position of a row of this arm, presented on graphitron_field_chain_link_resolution.position, whose comment carries what the value means

the via of a row of this arm, presented on graphitron_field_chain_link_resolution.via, whose comment carries what the value means

the to_source_name of a row of this arm, presented on graphitron_field_chain_link_resolution.to_source_name, whose comment carries what the value means

the to_schema of a row of this arm, presented on graphitron_field_chain_link_resolution.to_schema, whose comment carries what the value means

the to_table of a row of this arm, presented on graphitron_field_chain_link_resolution.to_table, whose comment carries what the value means

the reached_by_tail of a row of this arm, presented on graphitron_field_chain_link_resolution.reached_by_tail, whose comment carries what the value means

the reached_by_head of a row of this arm, presented on graphitron_field_chain_link_resolution.reached_by_head, whose comment carries what the value means

the capture instant that last wrote this row, the mark the stage sweeps against: a row the latest capture of its graph did not write again is one the corpus no longer has

the graph_name of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.graph_name through the arm table the row’s shape belongs to

the type_name of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.type_name through the arm table the row’s shape belongs to

the field_name of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.field_name through the arm table the row’s shape belongs to

the target_source_name of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.target_source_name through the arm table the row’s shape belongs to

the target_schema of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.target_schema through the arm table the row’s shape belongs to

the target_table of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.target_table through the arm table the row’s shape belongs to

the position of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.position through the arm table the row’s shape belongs to

the via of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.via through the arm table the row’s shape belongs to

the key_matched_by of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.key_matched_by through the arm table the row’s shape belongs to

the constraint_source_name of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.constraint_source_name through the arm table the row’s shape belongs to

the constraint_schema of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.constraint_schema through the arm table the row’s shape belongs to

the constraint_table of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.constraint_table through the arm table the row’s shape belongs to

the constraint_name of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.constraint_name through the arm table the row’s shape belongs to

the fk_on_from of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.fk_on_from through the arm table the row’s shape belongs to

the from_source_name of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.from_source_name through the arm table the row’s shape belongs to

the from_schema of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.from_schema through the arm table the row’s shape belongs to

the from_table of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.from_table through the arm table the row’s shape belongs to

the to_source_name of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.to_source_name through the arm table the row’s shape belongs to

the to_schema of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.to_schema through the arm table the row’s shape belongs to

the to_table of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.to_table through the arm table the row’s shape belongs to

the reached_by_tail of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.reached_by_tail through the arm table the row’s shape belongs to

the reached_by_head of a row of this rule, which the stage writes into graphitron_field_chain_link_resolution.reached_by_head through the arm table the row’s shape belongs to

the owning graph’s partition, carried from every rule’s base relation

the site’s owning type, the field’s parent

the site’s field name within the owning type

which rule resolved this site: PATH_TERMINAL (an authored @reference path’s terminal element), NAMED_TYPE_TABLE (the field’s named type’s own binding), PARENT_BINDING (the field’s own parent’s binding). A closed vocabulary of three disjoint rules, so it is also which boundary the site fell inside, and the column that lets a consumer tell an override from the parent’s own scope without re-deriving either

the resolved table’s catalog partition, the first column of the sql_table key this row names

the resolved table’s SQL schema

the resolved table’s SQL name. With the two columns above this is sql_table’s full key, so the table’s columns are one join away

the graph_name of a row of this rule, which the stage inserts into graphitron_field_column_scope.graph_name, whose comment carries what the value means

the type_name of a row of this rule, which the stage inserts into graphitron_field_column_scope.type_name, whose comment carries what the value means

the field_name of a row of this rule, which the stage inserts into graphitron_field_column_scope.field_name, whose comment carries what the value means

the basis of a row of this rule, which the stage inserts into graphitron_field_column_scope.basis, whose comment carries what the value means

the table_source_name of a row of this rule, which the stage inserts into graphitron_field_column_scope.table_source_name, whose comment carries what the value means

the table_schema of a row of this rule, which the stage inserts into graphitron_field_column_scope.table_schema, whose comment carries what the value means

the table_name of a row of this rule, which the stage inserts into graphitron_field_column_scope.table_name, whose comment carries what the value means

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

0-based position in the contextArguments list

the context argument name as written

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the SDL file the row was captured from

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

ExternalCodeReference.className as written

ExternalCodeReference.method as written

ExternalCodeReference.argMapping as written; the pair child below is its decode, the type_sdl-plus-decode pattern

as written; NULL when omitted (the FALSE default is derivable)

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the SDL file the row was captured from

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

the owning graph’s partition, carried from the minting row

the type the minted field sits on

the field’s own name

Type.field, on graphitron_field_authored.coordinate’s terms. The one place the element grain and this one part company: a rewritten carrier is an authored element and a minted field, so this coordinate can be one graphitron_element_authored also carries, where no other minted set’s can

where the expansion put it among the type’s fields; a rewritten carrier keeps the position its author wrote, the expansion restating it unchanged

the type expression the expansion wrote, wrappers included; for a rewritten carrier this is the whole of what changed

the name at the bottom of that expression

whether the outermost wrapper is non-null, which a rewritten carrier keeps from its author

whether the expression is a list

whether a list’s items are non-null, and nothing where it is not a list

always nothing, and stated here rather than carried: no macro writes a default onto an output field and every field minted or rewritten today is one, so the nullness is a property of this population rather than a column any arm declined to hold

the docstring the macro wrote; identical across the carriers that state one shared machinery field, which is what lets the distinct collapse them

whether this row restates a field the author wrote rather than adding one. The rewritten carrier is the only arm that does, and it is what tells the element arm which coordinates are already anchored by the transcription

the same fact as graphitron_field_minted.graph_name, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_field_minted.type_name, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_field_minted.field_name, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_field_minted.coordinate, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_field_minted.ordinal, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_field_minted.type_sdl, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_field_minted.named_type, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_field_minted.non_null, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_field_minted.is_list, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_field_minted.item_non_null, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_field_minted.default_value_sdl, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_field_minted.description, before the conflict and stand-down filters have withheld anything

the same fact as graphitron_field_minted.rewrite, before the conflict and stand-down filters have withheld anything

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the type owning the field

the field whose navigation this row states; with the two columns above the whole key, one row per field of the graph

which rung answered: CONNECTION_ELEMENT where the field’s named type is structurally a connection and this row names what it paginates, NAMED_TYPE where the field returns what it says it returns. A third rung took the expression the author wrote wherever a macro had rewritten it; it was retired once measurement showed every row it answered is the row these two answer, the expansion’s edges.node being the element the authored expression named.

the type name the field navigates as, wrappers already stripped. A name and never a binding, so a consumer joins graphitron_resolved_type_binding, intent_poly_member or graphql_type on it according to what it actually needs to know. Not null on any row, the lowest rung being the field’s own named type, so a reader joins this relation rather than left-joining it

when the reading that derived this row ran. The reading finishes by deleting this graph’s rows carrying a different instant, which are the coordinates a rewriting moved off; a field the author removed takes its row with it through the cascade above, so the two together are what let a second reading of one store land on the first’s rows rather than meeting them on the key

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the SDL file the row was captured from

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

typeName as written; author-spelled type reference, no FK, inference when NULL is a derivation

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

repeatable; document order

the SDL file the row was captured from

source line, 1-based per the graphql-java convention

source column, 1-based per the graphql-java convention

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the GraphQL type this row is about

the field name within the owning type

the owning @reference application’s ordinal

0-based within the application’s path

ReferenceElement.table as written (may carry a schema qualifier); it resolves through findTable, the same route the argument-site sibling takes

left of table_ref’s first period, NULL when no period appeared and the empty string when one appeared with nothing before it; for a table name this namespace is the SQL schema in every dialect jOOQ models. Written by capture, because splitting on a period is a decode and decodes happen there

right of table_ref’s first period, or the whole value when none; the empty string when a period was written with nothing after it, which joins nothing and is meant to

ReferenceElement.key as written (may carry a schema qualifier)

left of key_ref’s first period, NULL when no period appeared and the empty string when one appeared with nothing before it. This qualifier does not name the constraint’s own schema, because a constraint has none: it is scoped to its table, which is why sql_constraint takes its schema through the table. It names which schema’s table holds the constraint, disambiguating a constraint name that occurs in more than one, and the resolver reads it that way. Which namespace that is is dialect-dependent (the schema namespace in Oracle, the table namespace in PostgreSQL), which is why the column is not called a schema part

right of key_ref’s first period, or the whole value when none; joins sql_constraint.constraint_name narrowed by the source table the walk is standing on, not by this row alone

the fully-qualified Java class name as written

the Java method name as written

the argMapping string as written; the pair child is its decode

the upper-cased form of the column beside it, for the case-insensitive match against sql_table’s schema and name. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the upper-cased form of the column beside it, for the case-insensitive match against sql_table’s schema and name. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the upper-cased form of the column beside it, for the case-insensitive match against sql_constraint.table_schema_upper, the schema of the table holding the constraint. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the upper-cased form of the column beside it, for the case-insensitive match against sql_constraint’s constraint_name_upper and jooq_name_upper, in that precedence. Generated, so nothing writes it and nothing can. It exists because an authored spelling meets a catalog name here, which is the only reason anything in this schema is folded

the owning graph’s partition, carried from graphitron_field_reference_step_entry

the type owning the field the @reference is applied to

the field the @reference is applied to

the owning @reference application’s ordinal, since the directive is repeatable

the element’s 0-based position within its application’s path

which arm resolved the element, in a closed vocabulary of four: KEY where it named a constraint, TABLE where it named a table and a foreign key connects the two, NAME_MATCH where it named a table and the departure is a function result, whose hop is keyed by column name because it declares no constraints, CONDITION where it named neither and the route came off the condition method’s signature. KEY, TABLE and CONDITION are the author’s three spellings; NAME_MATCH is the second reading of the table spelling rather than a fourth thing to write. The element’s own written form is one join back to graphitron_field_reference_step_entry; this column is the resolution’s reading of it

for a KEY hop, which namespace answered: SQL_NAME (the SQL constraint name) or JOOQ_NAME (the generated Keys constant). NULL on a TABLE, NAME_MATCH or CONDITION hop, none of which names a constraint. Makes the resolver’s namespace precedence visible data instead of a hidden pick, as the column-match claim’s own tier column does

the departing table’s catalog partition, first column of its sql_table key

the departing table’s SQL schema

the departing table’s SQL name; a candidate departure, not yet a fact about the chain. On a NAME_MATCH hop the candidacy is wider than on the other arms, being every function result in the graph’s sources that exposes the arrival’s key columns rather than the endpoints of one named constraint, which costs nothing until a chain says where it actually stands

the arriving table’s catalog partition, first column of its sql_table key

the arriving table’s SQL schema

the arriving table’s SQL name

the foreign key the hop joins on, named or discovered. Its own sql_referential_constraint key is this name under whichever endpoint declares it, which fk_on_from says. NULL on a NAME_MATCH hop, which joins on no foreign key, and on a CONDITION hop, which joins on an authored predicate instead. The constraint a name-match hop does key by is the arriving table’s primary key, and that is left to the join rather than carried: sql_primary_key is keyed by the table, so the arriving triple this row already carries reaches it directly, and repeating it here would be the denormalisation the referenced-side discipline declines

TRUE when the departing table declares the foreign key, FALSE when the arriving one does; the hop’s direction, and what completes the constraint’s key from the two endpoint triples. NULL on a NAME_MATCH hop, where there is no foreign key to sit on either side and the direction is fixed by the arms themselves, a function result being always the departure, and on a CONDITION hop, whose direction is the method’s parameter order rather than a key’s orientation

the graph_name of a row of this arm, presented on graphitron_field_reference_step_hop.graph_name, whose comment carries what the value means

the type_name of a row of this arm, presented on graphitron_field_reference_step_hop.type_name, whose comment carries what the value means

the field_name of a row of this arm, presented on graphitron_field_reference_step_hop.field_name, whose comment carries what the value means

the ordinal of a row of this arm, presented on graphitron_field_reference_step_hop.ordinal, whose comment carries what the value means

the position of a row of this arm, presented on graphitron_field_reference_step_hop.position, whose comment carries what the value means

the via of a row of this arm, presented on graphitron_field_reference_step_hop.via, whose comment carries what the value means

for a KEY hop, which namespace answered: SQL_NAME (the SQL constraint name) or JOOQ_NAME (the generated Keys constant). NULL on a TABLE hop, which writes no name to match, which is inapplicable rather than omitted and is what the CHECK beside it states. Payload and never identity, which is why the two arms share one key shape and are one relation. Makes the resolver’s namespace precedence visible data instead of a hidden pick, as the column-match claim’s own tier column does

the from_source_name of a row of this arm, presented on graphitron_field_reference_step_hop.from_source_name, whose comment carries what the value means

the from_schema of a row of this arm, presented on graphitron_field_reference_step_hop.from_schema, whose comment carries what the value means

the from_table of a row of this arm, presented on graphitron_field_reference_step_hop.from_table, whose comment carries what the value means

the to_source_name of a row of this arm, presented on graphitron_field_reference_step_hop.to_source_name, whose comment carries what the value means

the to_schema of a row of this arm, presented on graphitron_field_reference_step_hop.to_schema, whose comment carries what the value means

the to_table of a row of this arm, presented on graphitron_field_reference_step_hop.to_table, whose comment carries what the value means

the foreign key the hop joins on, named or discovered; identity here rather than payload, both orientations of every constraint connecting one table pair being separate rows that nothing else tells apart. Its own sql_referential_constraint key is this name under whichever endpoint declares it, which fk_on_from says

TRUE when the departing table declares the foreign key, FALSE when the arriving one does; the hop’s direction, and what completes the constraint’s key from the two endpoint triples. Identity beside constraint_name for the same reason: a key is a hop in either direction and the two are different rows

the graph_name of a row of this arm, presented on graphitron_field_reference_step_hop.graph_name, whose comment carries what the value means

the type_name of a row of this arm, presented on graphitron_field_reference_step_hop.type_name, whose comment carries what the value means

the field_name of a row of this arm, presented on graphitron_field_reference_step_hop.field_name, whose comment carries what the value means

the ordinal of a row of this arm, presented on graphitron_field_reference_step_hop.ordinal, whose comment carries what the value means

the position of a row of this arm, presented on graphitron_field_reference_step_hop.position, whose comment carries what the value means

the via of a row of this arm, presented on graphitron_field_reference_step_hop.via, whose comment carries what the value means

the from_source_name of a row of this arm, presented on graphitron_field_reference_step_hop.from_source_name, whose comment carries what the value means

the from_schema of a row of this arm, presented on graphitron_field_reference_step_hop.from_schema, whose comment carries what the value means

the from_table of a row of this arm, presented on graphitron_field_reference_step_hop.from_table, whose comment carries what the value means

the to_source_name of a row of this arm, presented on graphitron_field_reference_step_hop.to_source_name, whose comment carries what the value means

the to_schema of a row of this arm, presented on graphitron_field_reference_step_hop.to_schema, whose comment carries what the value means

the to_table of a row of this arm, presented on graphitron_field_reference_step_hop.to_table, whose comment carries what the value means

the owning graph’s partition, carried from the hop view

the type owning the field the @reference is applied to; also the type whose binding started the chain

the field the @reference is applied to

the owning @reference application’s ordinal, since the directive is repeatable

the element’s 0-based position within its application’s path; positions are contiguous from 0 up to wherever the chain stopped

which arm resolved the element, as on the hop view: KEY, TABLE, NAME_MATCH or CONDITION

for a KEY element, the namespace that answered; NULL on a TABLE, NAME_MATCH or CONDITION element. As on the hop view

the departing table’s catalog partition; the type’s bound table at position 0, the previous element’s arrival after that

the departing table’s SQL schema

the departing table’s SQL name

the arriving table’s catalog partition, first column of its sql_table key

the arriving table’s SQL schema

the arriving table’s SQL name. At the path’s last position this is the table a @field(name:) on the same field resolves its column against

the foreign key this element joins on, named or discovered; NULL on a NAME_MATCH or CONDITION element, as on the hop view

TRUE when the departing table declares the foreign key; the element’s direction. NULL on a NAME_MATCH or CONDITION element, as on the hop view

how many distinct tables this element reaches, this row’s arrival being one of them; 1 where the destination is certain. Separate from candidates because the two arities answer different questions and genuinely differ: a table element with three foreign keys connecting the two tables reaches one table by three routes, so a reader that only needs the destination can trust it while a reader that has to render the join cannot

how many rows this element resolved to, counting routes and not just destinations; 1 is the walk’s requirement for an expressible hop, and a larger number is what its own "which foreign key did you mean" rejection counts

the graph_name of a row of this arm, presented on graphitron_field_reference_step_target.graph_name, whose comment carries what the value means

the type_name of a row of this arm, presented on graphitron_field_reference_step_target.type_name, whose comment carries what the value means

the field_name of a row of this arm, presented on graphitron_field_reference_step_target.field_name, whose comment carries what the value means

the ordinal of a row of this arm, presented on graphitron_field_reference_step_target.ordinal, whose comment carries what the value means

the position of a row of this arm, presented on graphitron_field_reference_step_target.position, whose comment carries what the value means

the via of a row of this arm, presented on graphitron_field_reference_step_target.via, whose comment carries what the value means

the key_matched_by of a row of this arm, presented on graphitron_field_reference_step_target.key_matched_by, whose comment carries what the value means

the from_source_name of a row of this arm, presented on graphitron_field_reference_step_target.from_source_name, whose comment carries what the value means

the from_schema of a row of this arm, presented on graphitron_field_reference_step_target.from_schema, whose comment carries what the value means

the from_table of a row of this arm, presented on graphitron_field_reference_step_target.from_table, whose comment carries what the value means

the to_source_name of a row of this arm, presented on graphitron_field_reference_step_target.to_source_name, whose comment carries what the value means

the to_schema of a row of this arm, presented on graphitron_field_reference_step_target.to_schema, whose comment carries what the value means

the to_table of a row of this arm, presented on graphitron_field_reference_step_target.to_table, whose comment carries what the value means

the constraint_name of a row of this arm, presented on graphitron_field_reference_step_target.constraint_name, whose comment carries what the value means

the fk_on_from of a row of this arm, presented on graphitron_field_reference_step_target.fk_on_from, whose comment carries what the value means

the targets of a row of this arm, presented on graphitron_field_reference_step_target.targets, whose comment carries what the value means

the candidates of a row of this arm, presented on graphitron_field_reference_step_target.candidates, whose comment carries what the value means

the graph_name of a row of this arm, presented on graphitron_field_reference_step_target.graph_name, whose comment carries what the value means

the type_name of a row of this arm, presented on graphitron_field_reference_step_target.type_name, whose comment carries what the value means

the field_name of a row of this arm, presented on graphitron_field_reference_step_target.field_name, whose comment carries what the value means

the ordinal of a row of this arm, presented on graphitron_field_reference_step_target.ordinal, whose comment carries what the value means

the position of a row of this arm, presented on graphitron_field_reference_step_target.position, whose comment carries what the value means

the via of a row of this arm, presented on graphitron_field_reference_step_target.via, whose comment carries what the value means

the from_source_name of a row of this arm, presented on graphitron_field_reference_step_target.from_source_name, whose comment carries what the value means

the from_schema of a row of this arm, presented on graphitron_field_reference_step_target.from_schema, whose comment carries what the value means

the from_table of a row of this arm, presented on graphitron_field_reference_step_target.from_table, whose comment carries what the value means

the to_source_name of a row of this arm, presented on graphitron_field_reference_step_target.to_source_name, whose comment carries what the value means

the to_schema of a row of this arm, presented on graphitron_field_reference_step_target.to_schema, whose comment carries what the value means

the to_table of a row of this arm, presented on graphitron_field_reference_step_target.to_table, whose comment carries what the value means

the targets of a row of this arm, presented on graphitron_field_reference_step_target.targets, whose comment carries what the value means

the candidates of a row of this arm, presented on graphitron_field_reference_step_target.candidates, whose comment carries what the value means

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the type owning the field the application was written on

the field the application was written on

the target table’s catalog partition, carried from graphitron_field_table; the first of the three columns naming which of a field’s chains this application stands in

the target table’s SQL schema, carried from graphitron_field_table

the target table’s SQL name, carried from graphitron_field_table. A field returning a multi-table interface has a chain per participant, so one application draws a row per participant and each is that participant’s own chain, which is why the target is in the key rather than beside it

the application’s position in document order, carried from graphitron_routine_entry, and what tells two applications on one field apart. @routine is repeatable and composes with @reference into one chain in written order, so a field can carry several and each resolves on its own terms; the ordinal is the chain’s order and not a count, the reference applications being numbered in the same sequence

the catalog partition of the table the routine’s result is, the first of the three columns naming it. Carried rather than derived, on graphitron_tabletype’s terms: the reference is a foreign key the engine checks and cascades, so a recrawled source takes the resolutions that named it

the result table’s schema as the catalog spells it, which is the catalog’s spelling and not the author’s: the match folds case on both sides and neither authored spelling survives into the row

the result table’s own name as the catalog spells it; with the two columns above, a foreign key into sql_table. A routine result is a catalog table of type FUNCTION, which is the whole of what makes this resolvable and is why the departure of a chain leaving a field with no table of its own can be named at all

when the reading that derived this row ran, on graphql_element.touched_at’s terms: swept per graph, and NOT NULL so the sweep is total. An application this reading no longer resolves leaves and the rest stay

the owning graph’s partition, carried from graphql_field on the upper rung and the participant arm and from graphitron_mutation_entry on the two mutation rungs

the type owning the field

the field whose scope this row states; with the two columns above and the table below, the grain

which rule answered, in a closed vocabulary of four: NAMED_TYPE_TABLE from the field’s named type’s own binding, PAYLOAD_TABLE from the single data channel of a DML write’s carrier payload where the payload itself binds nothing, MUTATION_TABLE from the @mutation(table:) spelling where neither of those answers, PARTICIPANT_TABLE from one branch of a named type that is a polymorphic container binding no table of its own. The first three are ranked rungs and the fourth is disjoint from all of them; which of them a row carries is therefore not only provenance but the fork a consumer takes, PARTICIPANT_TABLE being exactly where the coordinate is several statements rather than one. What lets a test pin which rule fired rather than only that a table came out; a reader wanting one of them filters on it and owns having chosen

the scope table’s catalog partition, the first column of the sql_table key this row names

the scope table’s SQL schema

the scope table’s SQL name; with the two columns above this is sql_table’s full key, so the table’s own columns and constraints are one join away

the graph_name of a row of this rule, which the stage inserts into graphitron_field_scope_table.graph_name, whose comment carries what the value means

the type_name of a row of this rule, which the stage inserts into graphitron_field_scope_table.type_name, whose comment carries what the value means

the field_name of a row of this rule, which the stage inserts into graphitron_field_scope_table.field_name, whose comment carries what the value means

the basis of a row of this rule, which the stage inserts into graphitron_field_scope_table.basis, whose comment carries what the value means

the table_source_name of a row of this rule, which the stage inserts into graphitron_field_scope_table.table_source_name, whose comment carries what the value means

the table_schema of a row of this rule, which the stage inserts into graphitron_field_scope_table.table_schema, whose comment carries what the value means

the table_name of a row of this rule, which the stage inserts into graphitron_field_scope_table.table_name, whose comment carries what the value means

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the type owning the field

the field whose endpoints this row states, over the population the generator emits rather than the one the author wrote: a field a connection macro minted has a target like any other and appears here, which is why the key points at graphitron_field and not at the transcription’s own anchor. graphitron_field_navigation spans the same two populations and is where this one gets them

the catalog partition of the table the field departs from, the first column of the sql_table key this row names. Functionally determined by the graph rather than independent of it: a capture reads exactly one jOOQ package, so within a graph the schema and the name already identify a table, which is why @table(name:) can spell one in two parts and needs no third. It is carried all the same because the engine cannot derive it. sql_table is source-keyed and shared between graphs, so without this column the reference here could not be a foreign key and a recrawled source could not take the rows naming it along with it. The same holds of to_source_name beside it

the departure table’s SQL schema

the departure table’s SQL name. Null at a root field, together with the two columns beside it, and that nullness is the fact rather than a gap: a field on Query or Mutation has no enclosing row to depart from, so its statement starts at the target. Null is therefore "this field is the start of its own path", which is also what makes a leading @routine legal only at a root

the catalog partition of the table the field’s rows come from; see from_source_name for why a column the graph already determines is stored

the target table’s SQL schema

the target table’s SQL name; with the two columns above this is sql_table’s full key, so the target’s columns and constraints are one join away

which rule named this target, in a closed vocabulary of three. NAMED_TYPE_TABLE: the field’s navigated type binds a table, the ordinary case, and the one a connection field reaches through the element it paginates rather than through its edge wrapper. PARTICIPANT_TABLE: the navigated type is a polymorphic container binding no table of its own, so each table-bound participant is a target and the field has several. ROUTINE_RESULT: the field’s chain ends on a @routine and the result table binds the return, which is why such a return needs no @table of its own. Provenance and fork at once, PARTICIPANT_TABLE being exactly where a reader holding one row holds one branch of several. Two rules that look like they belong here do not, and the boundary is what this relation is about rather than a gap in it: a DML mutation returning a carrier payload, and a @mutation(table:) on a return that names no table, each say where the mutation writes and not where the field’s rows come from. The carrier’s rows are fetched by its own data field, which has a coordinate and a row of its own here, and a delete returning a scalar has no rows at all. Both exist to give a mutation’s arguments a table to bind against, which is the argument scope’s question and answered where that is stated

when the reading that derived this row ran, on graphql_element.touched_at’s terms: swept per graph, and NOT NULL so the sweep is total. A target this reading no longer names leaves, and the links keyed into it leave with it; what does not happen is the whole partition emptying first, which is what the column is for

the owning graph’s partition, anchored by store_graph; the leading key dimension that keeps one workspace’s graphs apart

the type owning the field whose chain this link is part of

the field whose chain this link is part of

the catalog partition of the target this link’s chain leads to, the first column of the graphitron_field_table row this resolution belongs to

the target’s SQL schema

the target’s SQL name. With the two columns above and the coordinate, graphitron_field_table’s whole key: the target is not this link’s arrival but the arrival of the chain it stands in, which is why a field with several targets resolves its links once per target rather than once

the link’s place in the chain, carried from graphitron_field_chain_link, where the order is stated and what makes it an order is argued. Numbered from zero without a hole there; a hole here is a link this resolution could not answer for

which authored arm moved the chain, in a closed vocabulary of five. ROUTINE: the link is a @routine application and its arrival is the function result. KEY: the element named a foreign key, and the constraint columns beside this one say which and which way round. TABLE: the element named a table and a foreign key between the departure and it is what joins them. NAME_MATCH: the element named a table and the departure is a function result, which declares no foreign key, so the join is the whole primary-key name match sql_name_matched_key_column states. CONDITION: the element named neither a key nor a table and carried a condition, whose method signature declares both ends. Provenance and fork at once: it says which relation holds the link’s join columns, so a reader never has to try each in turn

which name the author’s key spelling matched, SQL_NAME for the constraint’s own name in the catalog and JOOQ_NAME for the generated constant’s, in that precedence. NULL off the KEY arm, no other arm matching a key name at all. The precedence is the generator’s resolver’s: a written qualifier binds against the schema of the table holding the constraint, an unqualified name matches the SQL name, and the generated name becomes eligible only where no SQL name in this graph’s sources answers

the catalog partition of the referential constraint this link joins through, the first of four columns naming it

the schema of the table the constraint is declared on

that table’s name. A constraint has no schema of its own; these two columns name the table holding it, which is the referencing side of the foreign key and not necessarily this link’s departure

the constraint’s own name as the catalog spells it, whatever the author spelled. With the three columns above, a foreign key into sql_referential_constraint, so the link’s column pairs are one join away. Carried here rather than recovered from the endpoints because two foreign keys may join the same pair of tables, so the endpoints do not name the constraint and a reader recomputing it from them would be guessing. NULL where the arm joins through no constraint

whether the departure is the side declaring the constraint, so the join runs along the foreign key rather than against it. Implied by which endpoint the constraint’s table matches, and carried anyway for the one case where that is no answer: a self-referential key declares both ends on one table, and this column is then the only thing saying which way the link runs. NULL exactly where no constraint answered

the catalog partition of the table this link departs from, the first of three columns naming it

the departure’s SQL schema

the departure’s SQL name; with the two columns above a foreign key into sql_table. The previous link’s arrival, or at position zero the enclosing type’s binding, which graphitron_field_table holds beside the target. Three columns or none of them, and none only on the ROUTINE arm: a function result is where a chain’s rows begin, so that link departs from nothing and the absence is the fact rather than a gap

the catalog partition of the table this link arrives at, the first of three columns naming it

the arrival’s SQL schema

the arrival’s SQL name; with the two columns above a foreign key into sql_table. The next link’s departure, and at the chain’s last link the target itself, which is the identity a reader can check and a mismatch is the chain not reaching what the field claims to return

when the reading that derived this row ran, on graphql_element.touched_at’s terms: swept per graph, and NOT NULL so the sweep is total. It is also what the walk reads: a link resolves from where the one before it arrived, and it matches that row on this reading’s instant so it departs from what this reading resolved rather than from a row the sweep is about to remove

the graph_name of a row of this rule, which the stage inserts into graphitron_field_table_link.graph_name

the type_name of a row of this rule, which the stage inserts into graphitron_field_table_link.type_name

the field_name of a row of this rule, which the stage inserts into graphitron_field_table_link.field_name

the target_source_name of a row of this rule, which the stage inserts into graphitron_field_table_link.target_source_name

the target_schema of a row of this rule, which the stage inserts into graphitron_field_table_link.target_schema

the target_table of a row of this rule, which the stage inserts into graphitron_field_table_link.target_table

the position of a row of this rule, which the stage inserts into graphitron_field_table_link.position

the via of a row of this rule, which the stage inserts into graphitron_field_table_link.via

the key_matched_by of a row of this rule, which the stage inserts into graphitron_field_table_link.key_matched_by

the constraint_source_name of a row of this rule, which the stage inserts into graphitron_field_table_link.constraint_source_name

the constraint_schema of a row of this rule, which the stage inserts into graphitron_field_table_link.constraint_schema

the constraint_table of a row of this rule, which the stage inserts into graphitron_field_table_link.constraint_table

the constraint_name of a row of this rule, which the stage inserts into graphitron_field_table_link.constraint_name

the fk_on_from of a row of this rule, which the stage inserts into graphitron_field_table_link.fk_on_from

the from_source_name of a row of this rule, which the stage inserts into graphitron_field_table_link.from_source_name

the from_schema of a row of this rule, which the stage inserts into graphitron_field_table_link.from_schema

the from_table of a row of this rule, which the stage inserts into graphitron_field_table_link.from_table

the to_source_name of a row of this rule, which the stage inserts into graphitron_field_table_link.to_source_name

the to_schema of a row of this rule, which the stage inserts into graphitron_field_table_link.to_schema

the to_table of a row of this rule, which the stage inserts into graphitron_field_table_link.to_table

the owning graph’s partition, carried from the column scope