Package-level declarations
Types
How a storage's presence operators see a stored null and an empty array.
How a storage aggregates. HAVING, top-N by a metric and dense date-histogram fill may be RESIDUAL; percentiles and distinct counts need the records themselves, so they are NATIVE or NONE.
The Catalog's compilation of one aggregate model (design §5.2): merges the declarations of sources into the logical model under sensitivity, asks the storage adapter for its facts about it, and compiles them into the published QueryModelSchema. The first load is shared by concurrent callers; a refresh reloads the sources and the storage's native structures and replaces the published schema only when it compiles.
Aggregated domain event streams: one record per command, typed event payloads under body[].body.
Declares the fields a QueryModelSource infers from the domain types of a built-in model.
A logical definition is shared unchanged with every native binding snapshot.
How a storage pages. Neither mode has a residual implementation, so each is NATIVE or NONE.
Where a logical field is stored for one capability. physicalScope is the physical container physicalField lies in whose elements storage indexes as separate documents, such as an Elasticsearch nested mapping, so a backend addresses the field through it; null when there is none.
A native binding as a storage adapter reports it; physicalScope is QueryFieldBinding.physicalScope.
The effective capabilities of one field, compiled once from its value definition, the capabilities storage grants it, its sensitivity, its element scopes and the model's storage support (design §5.2, P2). Admission checks each reference against this record, the descriptor publishes it, and it lists each capability with the cost class its spec states, which an entry gate that refuses expensive operations also reads. The value rules of the operator, group and metric specs are decided here, once, so admission and the descriptor cannot disagree about them.
One field or nested value: its shape (kind, types, nullability, structure) and semantics (enum, time, text).
One resolved field of a QueryModelSchema with its capability facts. Facts that depend only on the field and its schema are computed once per instance; static fields are resolved once per schema.
A serialized member: its JVM type and its effective annotations, those declared on the field, getter or inherited property it serializes from. Meta-annotations are not expanded.
How the Catalog compiles one aggregate model: from its context and its storage's facts to a schema provider.
Record layout and invariants of one built-in QueryModel.
Published facts only: model values and operation-specific native locations.
Type inference for the query Catalog: reports how a JVM type serializes, as raw facts.
Schema path parts; keys are captured by logical lookup, items describe array traversal.
The Catalog (design §4, §5.2): compiles the query schema of every aggregate model this instance serves, one provider per aggregate and model, with its compiler (by default the model sources merged under the sensitivity policy, see QueryModelCompiler.of). Each storage only reports its native facts, through the storage adapter its backend factory supplies. Gateways, point reads and the capability descriptor all read their schema here.
Declares, in code, what inference cannot know about a model's fields; the same vocabulary as a declaration file (see QuerySchemaDeclarationProperties).
The keys of a declaration file (META-INF/wow/query-schema/{context}.{aggregate}.{model}.json or config/wow/query-schema/…). A file only supplements what inference cannot know, in the capability descriptor's vocabulary:
How the query subsystem treats sensitive fields beyond their declared level.
A storage's port into the Catalog (design §5.2, §5.5): it reports what its native structures (indexes, mappings, validators) prove about a logical model, and nothing else. The Catalog merges the model's sources and compiles the reported facts into a QueryModelSchema, applying every rule that does not depend on the storage.
What a storage proves about one read model, in the storage-neutral vocabulary of capabilities: for each logical path, the capabilities its native structures can execute and the physical location each binds to, with the projection and response locations; and the storage's model-wide support. Which native types, index kinds or mapping options prove a capability is the storage's knowledge; what a logical value must be for a capability to apply at all is the Catalog's (compile).
A storage-neutral family of native types a logical value may be stored as. A storage adapter maps each family to its own native types (BSON types, Elasticsearch field kinds); which families a logical value needs for a capability is the Catalog's decision (storageFamilies).
Where a storage still departs from the strict table of storageFamilies. Each rule is a known divergence between storages, kept so that every adapter reproduces today's capabilities exactly; the defaults are the strict table.
One value of a serialized type.
One immutable logical value shape, shared by backend schema snapshots. Collection inputs are snapshotted; mutable enum JSON is detached on read.
The error catalog (design §5.9): every rule a query can break, as structured facts. Each violation names its stable code, renders its message from its facts, and belongs to a Kind that decides the error it becomes (rejection): the one place a rejection is rendered. Codes are a contract (added, never renamed); texts are not.
Materialized aggregate snapshots: one record per aggregate, payload under state.
What a storage declares beyond each field's native capabilities; bound into the schema by its adapter.
How storage supports a query feature (design §5.5).
The schema provider of an aggregate model that has no query backend: every load fails with message. QuerySchemaCatalog skips it, since there is nothing to load or revalidate.
The storage adapter of an aggregate model that has no query backend: every load fails with message. QuerySchemaCatalog skips it, since there is nothing to load or revalidate.
Functions
Flattens nested unions into their non-union alternatives; any other value is its own single alternative.
Describes how this model can be queried on one entry, derived from the same capability table and operator specs that admission reads, so the description and admission cannot disagree.
Whether any alternative of this value is an array, so storage may flatten it into multiple values.
Whether this value can be an element scope: every non-null alternative is an array whose non-null items are all objects, so a predicate can match one element as a whole.
Operations on primitive arrays use one member layer, without flattening the definition.
Returns the record identity of this schema's model, rejecting custom models that define none.
The native type families this scalar value needs for capability: one set per declared alternative, and storage proves the capability when its native types cover every set and fall in some set. An empty list, or a list with an empty set, means no storage can prove the capability for this value.
The logical field a system-field filter targets on this schema's model (QueryModelProfile.systemField). A custom model shares the record metadata fields but defines no identity, so an identity filter on it is rejected.
The query meaning of a QueryTypeFact at field: its structure as a declaration, with properties that are not valid query path segments left out, standard date formats as Temporal.Date, and member annotations applied.