What a schema may name in Java

One constant an author may name in @scalarType(scalar:), and the Java type its scalar coerces to.

One throwable on the classpath, which is what an author may name as an @error handler’s exception.

One method an author may name in @condition(condition:).

One method an author may name in @externalField(reference:).

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

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

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

the classpath entry the class was read from; the key’s leading dimension, and the reason one name declared by two entries is two classes. A graph reaches it through store_graph_source like any source-keyed fact

the fully-qualified binary name as the classfile spells it

the file it was read out of, under that entry. Not part of the key, a file being free to declare more than one class; the foreign key is what lets a file the next reading does not find take its classes, and their members, with it

when the reading that produced this row ran; swept with the entry it was read from

the entry the declaring class was read from, as on code_method; the key’s leading dimension

the declaring class, as on code_method

the method, as on code_method

the method’s descriptor, completing the key. The whole row is the key, on code_service_method.descriptor’s terms; the return type this arm admits on is fixed by the admission and would repeat its own predicate on every row

when the reading that produced this row ran; swept with the method it hangs on

the entry the declaring class was read from, as on code_method_parameter; the key’s leading dimension

the declaring class, as on code_method_parameter

the method, as on code_method_parameter

the method’s descriptor, as on code_method_parameter

the position, completing the key; with the four columns above, the parameter this resolution is of, and the row is deleted with it

the catalog partition holding the table, the first of three columns keying it

the schema the table is in, the second of the three

the table’s SQL name, the third. Keyed to sql_table rather than carrying the generated class name, so a reader joins a primary key instead of sql_table.class_fqn, which is no key and can match more than one row

when the reading that produced this row ran; swept with the parameter it hangs on

the entry the class was read from, as on code_class; the key’s leading dimension

the class being made, keyed into code_class because how a value is made is a fact about a class: a parameter names a type, but what is eventually constructed is the class that type delivers, and it is that class a compile can change. So a class the next reading does not find takes its construction and its write slots with it

POSITIONAL or SETTERS: whether the members go in through the constructor all at once or one at a time afterwards. A record is the first, everything else with a usable no-argument constructor is the second, and a jOOQ record is the second like any other, being made empty and then filled. Carried because two emitters fork on it and it is the decision rather than the evidence for it: reading it off the class’s declared form would put the rule in the readers

the constructor to call. At POSITIONAL that is the canonical one, whose parameters are the components in header order; at SETTERS it is ()V. Named by descriptor rather than by presence because a class may declare several and only one of them is the one this shape means

when the reading that produced this row ran; swept with the class it hangs on

the entry the declaring class was read from, as on code_method; the key’s leading dimension

the declaring class, as on code_method

the method, as on code_method

the method’s descriptor, completing the key. The table the lifter lifts from was a column here and is code_method_parameter’s role at position 0: a parameter’s type is the parameter’s fact, and a reader asking which table a lifter takes asks the position rather than the arm

when the reading that produced this row ran; swept with the method it hangs on

the classpath entry the declaring class was read from; the key’s leading dimension. With the class beside it this row hangs on code_class, so a class a compile removed takes its methods with it rather than leaving them until the whole entry goes

the declaring class’s binary name, the left part of what an author writes at a directive

the method’s own name, the right part of it. Not a key on its own: a name an author writes may denote several declarations, and the count of rows sharing one is what says so

the JVM method descriptor, completing the key. What tells two overloads apart, which no rendering of the erased types can: two methods taking same-named types from different packages render alike

whether the method is static. A property of the declaration rather than of any directive, though it is what @service reads to decide whether a holder is needed and what @condition folds on before admitting a set of overloads as one target

the type the method results in, by reference. Not a relation of its own beside the parameters, because a result is the one thing a method has exactly one of and it carries neither a name nor an ordinal to be bound at: a parameter binds a type to a named position, and a result is the type

the class the result type erases to, type arguments dropped: java.util.List for a List<Film> and the class itself where the type is one. NULL where it erases to no class, which a primitive, a void, an array and a type variable are alike in. Here rather than on a shared row because a parse is a fact about the position that wrote it: the dictionary that held it was keyed by the spelling, so it was shared by every class mentioning it and no per-class reading could decide its fate

the class the result delivers once its containers are peeled off, which is the question its readers ask: which class backs the GraphQL type this method produces. NULL where the type resolves to no class at all

how the result delivers that class, DIRECT where the type is one, WRAPPED inside an Optional and MANY inside a collection. What a field declared a list is checked against, a single-delivering method behind a list field being an author error. NULL with the element beside it

when the reading that produced this row ran; swept by the reading that replaces it

the entry the declaring class was read from, as on code_method; the key’s leading dimension

the declaring class, as on code_method

the method, as on code_method

the method’s descriptor, as on code_method; with the three columns above, the method this clause belongs to, and the row is deleted with it

the exception by binary name, completing the key. A set and not a list: the clause is read to decide whether same-named declarations agree and whether a field’s @error channel covers them, and neither comparison is order-sensitive, so declaration order would be a column nothing reads and a second way for two equal clauses to differ. Deliberately no foreign key to code_throwable: the classes a throws clause names are usually the JDK’s, which no classpath entry ships, so a name here is ordinarily a name and nothing further

when the reading that produced this row ran; swept with the method it hangs on

the entry the declaring class was read from, as on code_method; the key’s leading dimension

the declaring class, as on code_method

the method, as on code_method

the method’s descriptor, as on code_method; with the three columns above, the method this position belongs to, and the row is deleted with it

the position in the parameter list, 0-based, completing the key. Position is the key and not the name, because a name is what a classfile may omit and a position is what it always carries

the parameter’s name as the source declared it, or NULL where the class was compiled without -parameters and the classfile carries no MethodParameters attribute. What a GraphQL argument binds to and what an argMapping entry targets, so a run that finds it absent refuses the binding rather than guessing; a reader must not read NULL as an unnamed parameter

the type bound at this position, by reference. A parameter is a binding rather than a description: what the type is and what it resolves to are the type’s own facts and are stated once however many positions carry it, which over this module’s main sources is thirteen hundred positions over two hundred types

the class the parameter type erases to, on code_method.result_erased_class' terms; what a binding compares against when it asks whether an argument can be passed here

the class the parameter delivers once its containers are peeled off, on code_method.result_element_class' terms

how the parameter delivers that class, on code_method.result_delivery' terms; NULL with the element beside it

what the position is for as far as its type alone decides, in a closed vocabulary of four, and the four are exclusive because no type satisfies two of them. DSL_CONTEXT: the run’s own jOOQ context is passed here. TABLE_CONCRETE: the declaration names one generated table, and code_condition_method_parameter_table says which where the catalog holds it. TABLE_ANY: the declaration is org.jooq.Table itself, raw or wildcarded, or a type variable, so the position takes whatever table the site supplies. OTHER: everything else, whose role is the application’s to decide from the arguments and context keys in scope at the site. Decided here rather than by a reader because deciding it needs an assignability walk, which a reader either re-derives through a recursive closure or asks a loader for

how a value bound to this position is coerced into it, decided by the declared type alone: ENUM_VALUE_OF where that type is an enum and DIRECT otherwise. The standing rule rather than the last word, a parameter bound to a slot carrying @nodeId receiving that slot’s decoded key instead, which intent_condition_param_decode states as the exception to this. Decided by loading the class, which is what makes it answerable for both populations at once: an author’s own enum and a generated one a column binds to, the second living in the package this reading excludes and so reachable no other way

when the reading that produced this row ran; swept with the method it hangs on

the entry the declaring class was read from, as on code_method; the key’s leading dimension

the class offering the member, which is the class an author names and not always the class the accessor is written on. A member a base class declares is one the subclass offers, so this is where the walk found it rather than where it was declared. Keyed into code_class, so a class offering members is one the reading actually read rather than a name appearing here and nowhere else

the method that reads the member. The accessor is the key rather than the name an author writes, because the name is the part that is not unique: a class spelling one property getTitle and isTitle offers title twice

the method’s descriptor, completing the key: two accessors of one name on one class are two slots, which is what overloading is

the class the accessor is written on, which is the class a jump to the member’s own source lands in. Equal to the offering class wherever the class declares its own member and different wherever it inherits one. No foreign key, for the reason the write side names the call it makes without keying to it: a base class may be read from a different classpath entry than the class offering its members, so the method’s own row sits under a key this one does not carry, and a constraint would refuse exactly the inheritance this column exists to record

the name @field(name:) resolves against: a record component’s own name, or the property a getter offers, which is the remainder after get or is with its first letter lowered. Deliberately not unique within a class, two spellings of one property being two rows; a reader wanting one takes the first and a reader offering candidates offers both

what reading the member yields, as code_type spells it. Carried rather than reached through the accessor’s own row, because what a member yields is a fact about the class offering it and not about the method behind it. The two agree wherever a class declares its own member. They part at inheritance: an inherited accessor has no row under the offering class, and its base may have been read from another entry or not read at all, so a slot typed only through one could not exist. And a base class declaring K getId() offers Integer to a subclass extending it at Integer, which only the offering class can say. The spelling is the accessor’s declared result today, type variables unsubstituted, so that case reads K here; this column is where the substituted type goes when the reading states it

the class what the member yields erases to, on code_method.result_erased_class' terms. Here rather than through the accessor for the reasons slot_type gives

the class the member delivers once its containers are peeled off, on code_method.result_element_class' terms: which class backs the GraphQL type a field reading this member produces

how the member delivers that class, on code_method.result_delivery' terms; NULL with the element beside it

RECORD_COMPONENT or BEAN_ACCESSOR, which is a fact about the offering class rather than the member: a class takes exactly one arm, chosen by its declared form, so a record answers with its components and anything else with its getters. Carried because two readers turn on it, one choosing where a go-to-definition lands and one choosing the noun a diagnostic uses

when the reading that produced this row ran; swept with the accessor it hangs on

the classpath entry the owning class was read from, anchored by store_source; the key’s leading dimension, and what a reader joins through to scope by origin or by the graph’s own source set

the owning class’s binary name, the left part of the reference an author writes

the constant’s own name, the right part of that reference; completing the key

the fully-qualified Java type a value of this constant’s scalar arrives as, the input parameter of the Coercing it holds, boxed where that is primitive. NULL where the constant does not resolve to one, which folds four cases this arm does not tell apart: the class does not load, the field is not a public static GraphQLScalarType, its initialiser throws, or the coercing declares no usable input. The one column here that a classfile cannot answer, read by loading the class instead, so absence is unresolved and never not-a-scalar

when the reading that produced this row ran; the reading ends by deleting the rows of the entries it read that still carry an older instant, which are the constants a recompiled entry no longer declares

the entry the declaring class was read from, as on code_method; the key’s leading dimension

the declaring class, as on code_method

the method, as on code_method

the method’s descriptor, completing the key. The whole row is the key: what the method returns and takes is code_method’s and does not vary by the directive that reached it, so membership is the only thing this relation has to say

when the reading that produced this row ran; swept with the method it hangs on

the classpath entry the class was read from, anchored by store_source; the key’s leading dimension, and what a reader joins through to rank a candidate by origin or by coordinate

the throwable’s binary name, which is what an author writes; completing the key

when the reading that produced this row ran; the reading ends by deleting the rows of the entries it read that still carry an older instant, which are the throwables a recompiled entry no longer declares

the entry the throwable was read from, as on code_throwable; the key’s leading dimension

the throwable this row is about, as on code_throwable; the row is deleted with it

one type the throwable is, by binary name, completing the key. java.lang.Throwable is a row on every throwable, being the admission fact itself, and java.lang.Object is a row for the same reason it is one on sql_table_record_supertype: this states what the class is rather than what its source declared, and a throwable is an Object

when the reading that produced this row ran; swept with the throwable it hangs on

the classpath entry whose signatures mention the type; the key’s leading dimension, so a type is swept with the entry that mentioned it rather than outliving it. A type name is global and this relation is not, which is the same trade every relation in the family makes: what a reading read is what it can answer for

the type as the source declared it, type arguments kept and packages kept, which is what makes it a key: two Foo<X> from different packages render alike and are two types. A primitive is its own spelling and an array is its component’s with brackets, so the three silences a resolution cannot tell apart, a primitive, an array and a type variable, are told apart here by the name itself. A type variable spells only its own identifier, so two methods writing T share this row; that costs nothing while the only thing stored about it is that it resolves to no class, and stops being adequate the moment anything method-specific is

the same type with its packages dropped, which is what a surface shows a person: List<Film> where the name beside it is java.util.List<no.sikt.example.Film>. A rendering and not an identity, which is why it is not the key: two Foo<X> from different packages render alike. Here rather than at each site because a rendering is a property of the type, so it is stated once per type rather than once per position carrying one, and here rather than nowhere because the editor surfaces render a member’s type and a store that held only identities could not tell them what to show

the fully-qualified class the type names at its root position, type arguments dropped: java.util.List for a List<Film>, and the class itself where the type is one. NULL where the root names no class, which a primitive, a void, an array and a type variable are alike in, so a reader asking what a value has to be to be assigned here reads the absence as "not a class" and does not have to tell those four apart; type_name does tell them apart, for the reader that has to. What a position accepts, and deliberately not how many it accepts: a List<Film> accepts a list, and that it delivers films is code_type_element.delivery’s answer to a different question. The two are stated separately because they diverge exactly where it matters, a reader comparing against a jOOQ record class wanting the list and a reader asking whether one value can be handed over wanting the films

when the reading that produced this row ran; swept with the entry it was read from

the entry whose signatures mention the type, as on code_type; the key’s leading dimension

the type, as on code_type, completing the key; the row is deleted with it

the binary name of the class the type arrives at once every container is peeled off it. Presence is the fact this relation states, which is why the columns are not on the type: a void, a primitive, an array and a type variable name no class, and a placeholder would make four different silences look like one answer. Not a foreign key: a type delivering a class no classpath entry declares is the ordinary case at the end of a declared type, so a reader learns the name here and learns nothing further about it

how a caller receives what the type hands over: DIRECT where the type is the class and nothing was peeled, WRAPPED where containers were peeled and none of them multiplies, MANY where at least one does. A List, a Set, a Collection or a jOOQ Result multiplies; an Optional, a CompletableFuture or a Map does not, those being one value in a wrapper. The decision rather than the containers behind it, which is what lets a reader ask its own question without knowing the vocabulary: whether one value may be handed to a position is DIRECT, and whether a field backed by this type is a list is MANY. Stating it as the container’s own name would make both questions a test against a class name, and a rule that turns on java.util.List not happening to equal java.lang.Integer is a coincidence doing load-bearing work

when the reading that produced this row ran; swept with the type it hangs on

the entry the class was read from, as on code_construction

the class being made, as on code_construction; the row is deleted with it

the call that fills the member: the constructor at POSITIONAL, where every slot names the same one, and the setter at SETTERS, where each names its own

that call’s descriptor, completing its key

which argument of the call carries the member, counted from zero. At POSITIONAL it is the component’s place in the record header, which is what makes the call emittable in one go; at SETTERS it is zero, a setter taking one argument. Part of the key because one call carries many members at POSITIONAL and the argument is what tells them apart

the name @field(name:) resolves against on an input: the record component’s own name, or the property a setter fills, which is the remainder after set with its first letter lowered. Deliberately not unique within a class, on code_read_slot’s terms: a class spelling one property two ways offers it twice and this relation declines to choose between them

what the member is filled with, as code_type spells it. The write side’s answer to the question code_method.result_type answers for reading: a value bound here is coerced into this type. Carried with its parse rather than reached through the call’s own row, because a POSITIONAL call is a constructor and constructors have no code_method row, and an inherited setter has none under the class being made; the write side is a parameter position and says so on code_method_parameter’s terms

the class the member’s type erases to, on code_method_parameter.erased_class' terms

the class the member takes once its containers are peeled off, on code_method_parameter.element_class' terms: which class the value bound here is built as

how the member takes that class, on code_method_parameter.delivery' terms; NULL with the element beside it

when the reading that produced this row ran; swept with the construction it hangs on