Skip to main content

IndexModel

Struct IndexModel 

Source
pub struct IndexModel {
Show 22 fields pub prefix: EmissionPrefix, pub index: Ident, pub kind: NodeKind, pub vis: Visibility, pub krate: Path, pub source: Upstream, pub dedup: Dedup, pub embeddings: Vec<Elected>, pub labelled: Vec<Labelled>, pub searchable: Vec<Ident>, pub engines: Vec<FieldEngines>, pub stores: Vec<Engine>, pub extension: Option<Extension>, pub data: bool, pub keys: bool, pub subscribe: bool, pub graphql: Option<IndexGraphql>, pub numbers: Numbers, pub field_numbers: Vec<FieldNumbers>, pub rename: Option<IndexRename>, pub slot: Option<LitStr>, pub fields: Vec<Column>,
}
Expand description

A validated derived index: which storage it is, what it draws from, and the fields it declares.

PLAIN, for RecordModel’s reason — public fields, no constructor, nothing that parses — so the derive today and a manifest front end later build the same one.

Fields§

§prefix: EmissionPrefix

The EMISSION NAMESPACE this declaration’s minted names wear.

EmissionPrefix::INGRAPH for everything ingraph’s own front ends build, and a domain framework’s own mark for a model mediagraph-codegen or its successors build — see crate::prefix for what the seat covers and why it is a field rather than a constant.

§index: Ident

The index’s own name — the declaration this model came from.

§kind: NodeKind

WHICH of the three storages this is.

Spent on the sentences a front end writes, on which SEAM the emitted doors name — a full-text engine or a vector one — and on nothing else this emission does: all three mint the one-storage marker and all three carry the upstream’s key. WHICH engines hold the documents is no longer read off the kind at all: it is engines, declared per field.

§vis: Visibility

How visible the index is, and therefore how visible each emitted method is.

Mirrored rather than fixed at pub, exactly as a record’s: no one can widen a type they did not declare.

§krate: Path

The path to the ingraph crate itself — ::ingraph unless crate = "…" named another.

§source: Upstream

The ONE upstream this index draws from, and what it takes from it.

One rather than a list: several upstreams key a derived index by an ENUM over their keys, and the field that carries it is a different field of a different type. The model holds what this emission spends.

§dedup: Dedup

The dedup MECHANISM a retrieve over this index runs — the dedup(…) word, or its default.

Spent by the two emitted retrieve methods and by nothing else, which is also why it is on the model rather than on Upstream: it is a property of how this node ANSWERS, not of where its documents came from.

§embeddings: Vec<Elected>

WHICH fields a knn over this index may run over — every knn-marked field, on the one kind that has any.

NON-EMPTY on every VECTOR declaration and EMPTY on the other two, and the asymmetry is the marker’s own: it is mandatory where it applies and refused by name where it does not, so a front end that produced an empty list for a vector has already refused the declaration. In DECLARED order, which is the order the emitted columns and the record face are written in.

A LIST rather than one, because a declaration may elect several and each is queryable — see Elected for the geometry that carries them and for why the role is declared rather than read off the type.

§labelled: Vec<Labelled>

Every LABELLED field NO election names — the forward declarations, in declared order.

§A label on payload is ACCEPTED, and that is a ruling rather than an oversight

The label states a STRUCTURAL fact about a field — one embedding, or a set of them — and the party that will spend it is not only the query side. A storage layer that lays a set out differently from a single vector, or that carries a weight per member, reads the same fact about a field nothing queries. So a labelled field with no election is a declaration made EARLY rather than a word nobody reads, and this crate’s usual refusal — a word parsed into a model nothing spends is a promise rather than a rule — does not reach it.

What the acceptance does NOT buy is a face: no column, no door, no projection. The election marker is still what grows those, and a labelled payload field is hydrated by its own accessor exactly as an unlabelled one is.

ACCEPTED IS NOT UNEXAMINED. The label’s claim is audited here as it is on an election, so a payload field labelled list(embedding) over a single embedding is E0277 at its own type.

§searchable: Vec<Ident>

WHICH fields a search over this index runs over — every searchable-marked field, on the one kind that has any.

embeddings’ mirror one kind over, and the same law: NON-EMPTY on every FULL-TEXT declaration, EMPTY on the other two, in DECLARED order.

§Idents rather than an Elected, and the asymmetry is the ENGINE’s rather than this model’s

An election carries what the EMISSION has to read off it, and the two kinds hand over different amounts. A knn’s column is opened at an element and a width, so Elected carries E, N and the space it lives in — every one read off the field’s own type, all three spent on the query type the emitted pair takes. A search takes a STRING, and what a searched field must BE is not this crate’s to say: FulltextRecord::Document is deliberately bound by nothing, what a document must be is the searching engine’s question. So the name is the whole of what a full-text election has to carry, and inventing a shape for it here would answer that question for engines that have not arrived.

What it is SPENT on is BOTH halves of the read face. The whole-subject pair’s doc line names the fields it searches — the sentence that used to say every projection — and each name in this list also mints its own retrieve_keys_by_<field> / retrieve_by_<field> pair, at vector parity, narrowing to a one-column FulltextSubset. The selector the per-field doors waited on is the seam’s now: FulltextRead::search takes the subset beside the query.

§engines: Vec<FieldEngines>

WHERE each elected field is written — one entry per election, in declared order, carrying the engine blocks that field wore and whether all of them are live at once.

ONE list over BOTH kinds, kept in step with the elections above by construction: the engine grammar is one grammar, and a knn’s field and a search’s field name their engines alike. An election that named NO engine has an entry with an empty list — declaring none is legal, and means the deployment says instead, which is what a record with no persist(…) means one family over.

See engine for the semantics this carries: several blocks are declared PORTABILITY, the default is SINGLE-WRITE, and fanout is the one departure.

§stores: Vec<Engine>

WHERE an ARTIFACT FAMILY’s objects are written — the engine blocks a blob declaration wrote at its HEAD, beside upstream(…).

NON-EMPTY only on a blob, and the reason it is a second list rather than an entry in engines is that the GRAIN differs. A slot on the other two kinds is (field × engine), because a declaration elects several fields and each is searched independently; an artifact family elects nothing and holds ONE object per message, so its slot is (declaration × engine) and the head is the only position coarse enough to name it. Writing blob engines on a field would have asked which of a payload’s fields the object is — a question with no answer.

The SEMANTICS are the field grammar’s, unchanged: several blocks are declared PORTABILITY, the deployment selects, and the default is SINGLE-WRITE. fanout is NOT among them — see the fanout refusal on this kind, which names the deferral rather than pretending the word is unknown.

EMPTY is legal and means the deployment says instead, exactly as a record with no persist(…) does one family over.

§extension: Option<Extension>

HOW this family’s addresses END — the extension word, in whichever of its forms was written.

None is the OMITTED form and a real one: extensionless storage, which a heterogeneous family takes at zero tax, its per-entry type travelling as metadata or as the host channel’s Content-Type. It is not unset — there is nothing to set it to.

NON-None only on a blob; extension on the other two kinds is refused by name.

§data: bool

WHETHER this family’s BYTES may travel beside its address — the bare data word at the head.

An artifact family answers an ADDRESS, and the whole kind is built around that posture: what a caller is handed is where the object lives, and going to get it is a second hop against the store. On a family of large objects that is the only sane answer — nothing wants a video inlined into a response. On a family of small ones the hop costs more than the bytes it fetches, and a thumbnail served as an address alone is a round trip bought for nothing.

data is where a declaration says which of the two it is. WRITTEN, this family’s object may be served inline — base64, BESIDE the address rather than instead of it, so nothing a caller could already reach stops being reachable. OMITTED, the address is the whole of what is served, and that is a real form rather than an unset field: it is the default because it is the one that cannot hand anybody a payload they did not ask for.

A BOOL because the word carries nothing — no value and no block, since these bytes may be served has no knob inside it. MAY rather than WILL is the deliberate half: what a DECLARATION can settle is whether inline bytes are on the table for this family at all.

false on the other two kinds ALWAYS — data there is refused by name, for data_wrong_kind’s reason.

§keys: bool

Whether this declaration’s upstream is an ENTITY, so its dressed answer family mounts the KEYS TIER ALONE — the keys word.

§The word declares a TIER FACT, and the two clocks are why one exists at all

A dressed election answers each road twice: the KEYS tier hands back addresses and touches no store, the HYDRATED tier hands back the upstream’s whole entities and reads them out of one. The hydrated pair projects <Upstream as Hydrates>::Db, whose impl only a record with a queryable row emits — so which tiers this declaration can mount is decided by which RUNG of the record ladder its upstream sits on, and the two derives cannot see each other.

false — a RECORD upstream — mounts BOTH, unconditionally and with no word to write: rows are a record’s essence now, so storage is guaranteed and hydration can never miss. true — an ENTITY upstream — mounts the keys tier, which is the pure-engine deployment’s honest home: a search surface over a node whose messages land in no database anywhere.

A declaration that has an entity upstream and writes NO word is not silently narrowed. The hydrated demand is emitted, the compiler cannot satisfy it, and the E0277 lands at upstream(node = "…") carrying Hydrates’ own sentence — which names both exits, persist the upstream or wear the word. Guessing here would be this crate deciding a deployment’s storage posture from what happens to compile.

false on blob ALWAYS: an artifact family answers an address rather than a ranking, so it mounts no tier pair for the word to narrow, and the word is refused there by name.

§subscribe: bool

WHETHER THIS DECLARATION LAUNCHES — the bare subscribe word at the head.

false is the HAND ROAD and it is the shipped one: the declaration mints its corpora, its slot markers and its search doors, and a deployment fills those corpora through the branded handle itself. Every expansion this crate wrote before the word existed is that road, and none of them moves — subscription is purely additive, so the emission below is the only thing the word adds and nothing it touches is rewritten.

true mints a NODE beside the declaration — see subscriber — which the deployment mounts like any other, and which receives the upstream’s messages, projects them per this declaration’s own upstream(…) entries, and lands them in the corpora this declaration already names.

false on every kind but fulltext, where the word is refused by name: the write lane is a per-family seam and the full-text one is the family with a live engine behind it.

§graphql: Option<IndexGraphql>

WHICH GRAPHQL BACKENDS this declaration is dressed for — see IndexGraphql for the law the word states.

None is no wire face, and it is a real form rather than an unset field: a declaration with no block emits every Rust type and every door it would otherwise emit, and emits no wire impl for any of them. Nothing is missing programmatically — what is missing is a schema, which is what a backend-only search pipeline wants.

§numbers: Numbers

THE CONTAINER TIER’s numbers — limit, depth and ceiling written at the head.

Empty is the ordinary state and means the framework’s own answers stand; see Numbers for the trichotomy the three words divide into, and wire_first / pool_depth / declared_ceiling for the three chains that read them.

§field_numbers: Vec<FieldNumbers>

THE ELECTION TIER’s numbers, one entry per field that wrote one — in the order the declaration wrote the fields.

A field with nothing written on it has NO entry rather than an empty one, so the list is exactly what a declaration said and a chain that finds nothing falls to the container.

§rename: Option<IndexRename>

WHAT THIS DECLARATION’S MINTED RUST TYPES ARE CALLED — see IndexRename.

None is the declaration’s own ident is the base, which is where this family started and is what every declaration written before the word arrived means.

§slot: Option<LitStr>

WHAT THIS FAMILY’S CORPUS IS CALLED WHERE IT IS STORED — the slot = "…" word, blob only.

§A DURABLE name, which is the whole reason it is not the Rust rename

The slot is the directory an artifact family’s objects live under, and it survives every rebuild: two deployments of one declaration address the same objects because they agree on this string. So it is deliberately NOT moved by rename — a Rust word repointing a live store would be a rename that loses data — and it is deliberately additive: the DEFAULT stays snake_case(<declaration name>), which is what every family written before the word arrived is stored under.

None is that default rather than an unset field. Non-None only on a blob: the other two kinds’ slots are (field × engine) pairings and a declaration-level word is the wrong grain for one, which the front end says by name.

§fields: Vec<Column>

EVERY field the index declares, in declared order — the injected key field is NOT among them, being the emitter’s rather than the declaration’s.

A Column rather than a Field, for FieldsModel’s reason: a Field carries identity and a reference, and every field here is on the same side of an identity it does not hold.

Implementations§

Source§

impl IndexModel

Source

pub fn tier(&self) -> Tier<'_>

This declaration’s TIER of the fusion tree — see fuse for the packages it mints and the binding table that picks which one a parent absorbs.

A borrow of the lists this model already holds, rather than a second copy of them.

Source§

impl IndexModel

Source

pub fn base(&self) -> &Ident

THE BASE EVERY MINTED NAME IS BUILT ON — the top-level rename’s word, or the declaration’s own ident.

The one place the two are chosen between, so that a name minted anywhere in this crate cannot be built on the wrong one. NOT the same question as what is this type called: the declaration’s own ident is what an impl … for writes and what a doc link points at, and it never moves.

Source

pub fn emit(&self) -> TokenStream

The whole expansion: the one-storage marker at module scope, and everything else inside the anonymous const this crate puts every impl in.

The marker CANNOT move inside that const — see one_storage_marker; two of them in two anonymous consts are two items in two scopes and collide with nothing at all.

Source

pub fn mounts(&self) -> bool

WHETHER THIS DECLARATION MOUNTS AT ALL — a retrieving kind wearing a backend word.

The presence law at the tier that mints the unit: a declaration with no graphql(…) block emits every Rust door and package it would otherwise emit, and mints no citizenship — which is exactly what a backend-only search pipeline wants.

Source

pub fn queries_name(&self) -> Ident

<Decl>Queries — this declaration’s query unit, re-based by the BONES rename like every other name it mints.

No piece word of its own, on the record unit’s precedent: the unit is a Rust type a root spells once and a schema never sees, so a name for it is the base’s business. The base moves it because the base moves the whole family — a rename that reached the packages and left this one behind would put two stems in one declaring scope.

Source

pub fn unmounted(&self, field: &Ident, which: Field) -> Option<&'static str>

WHY THIS ELECTION PUBLISHES NO which QUERY FIELD, or None where it publishes one.

§The law: seats may sit EMPTY, and a written word must point at something MINTED

An unwritten seat is a capability nobody has asked for yet and costs a declaration nothing. A WRITTEN one that reaches no emitted name is a swallowed authoring error — the class this house already refuses at lineage(rename) on a lineage-less record — because the author believes they renamed a field and the schema still publishes the derived name, or publishes nothing at all.

§What it reads is the DECLARATION’S OWN SHAPE, and that is the whole of its scope

Two facts decide which roads an election mounts, and both are the declaration’s:

  • a FANNED election publishes the fused field alone. Its four sibling roads are not emitted, because vector_fuse_by_<field> is the one door a multi-store election has.
  • the head’s keys word says the upstream is an ENTITY, so the answer family mounts the KEYS tier alone and the two hydrated roads have no store to read rows out of.
§Three cases it deliberately does NOT answer, each measured

Field::Fused always answers None here. It is unmounted on a plain election exactly as its siblings are on a fanned one, and auditing it is a one-line change to the match below — but the round that wrote this law enumerated four roads, so the fifth is left for a ruling rather than taken by symmetry.

A FULL-TEXT election mounts no query field at all: answer_roads returns nothing for that kind, so every seat on one is currently unspent. That is the ANSWER FACE not having arrived for the kind rather than a shape the author chose, so a refusal there would be this crate claiming the face is never coming.

An election naming its engines BY WORD ALONE publishes no field either — the portable case, which is legal and means the deployment picks the engine — and the same reasoning holds: the surface is absent for a reason outside the seat’s own axis.

Both are recorded here rather than fixed, so the next reader inherits the measurement.

Source

pub fn unminted_engines(&self, field: &Ident) -> Option<&'static str>

WHY THIS ELECTION MINTS NO <Index><Field>Engines, or None where it mints one.

unmounted’s law at a TYPE seat rather than a field seat. The per-leg product is minted by the fused answer and by nothing else — a fused read states one floor per leg, and an election answered by one store has one leg and names it through the @oneOf selector at the head instead.

Its sister seat question(rename = "…") has no such clause, and that is a MEASUREMENT rather than an omission: question_input runs for every election that mounts a road at all, on every road, so the question type is minted wherever the seat is reachable. The seat is audited and found always-spent, which is a different answer from unaudited.

Source

pub fn field_name(&self, elected: &Elected, which: Field) -> String

WHAT ONE ELECTION’S QUERY FIELD IS CALLED — the declared word verbatim, or the derived name.

#[ingraph(embedding, knn, lance(resource = "…"),
          graphql(async_graphql(keys(rename = "clipNeighbours"))))]
                                     └── replaces the whole name

VERBATIM, and that is the choice worth stating: the derived name is composed from three parts — the declaration, the election and the road — so a word that re-cased or re-composed what an author wrote would be a rename they could not predict from what they typed. The front end holds it to GraphQL’s own Name grammar at the literal, which is where a caret can land.

§The resolution is MEMBER, then BASE-DERIVED, then DEFAULT

The road’s own word answers first. Where it wrote none, the DERIVED half reads the rename-aware base, so rename = "…" moves the field with the rest of the family; and where the declaration wrote no base either, the derived name is built on its own ident. The declared half never moves with a base, being a name in the SCHEMA’s namespace rather than Rust’s.

§FIVE seats for five roads, which is what closed the composition question

A declared word is VERBATIM, so it cannot be composed: a seat for the keys road says nothing about what its hydrated twin should be called, and deriving clipNeighboursHydrated from clipNeighbours would be the composition the verbatim law refuses. Two more seats was therefore the only shape a word for the hydrated roads could take, and the 2026-08-16 rename ruling minted them — so the seat set and Field are now one closed five, matched by ElectionBackend::road where a missing arm is a compile error rather than a silent fallback.

Source

pub fn road_name(&self, field: &Ident, which: Field) -> String

field_name over a bare ident — the shape the FULL-TEXT kind has, whose elections carry a name and nothing else.

One body for both, so the rename seat a vector election reads and the one a searchable field reads cannot come to disagree about which word wins.

Source

pub fn slots(&self) -> Vec<Slot>

EVERY slot this declaration names — one per (elected field × declared engine), in declared order.

The set the storage plumbing is keyed by, and the answer to how many corpora does this declaration own. It is EMPTY for a declaration whose elections named no engine, which is the portable case: the slots exist, and which engines they are opened on is the deployment’s.

Source

pub fn carried_key(&self) -> Field

γ′ — the ONE field this expansion adds to the item its author wrote.

Minted here rather than at the front end that injects it, so that the name, the type and the visibility are decided by the code that also reads them back: new takes it, key_ref borrows it, the entity binding answers through it, and all four are above.

pub(crate), which is the stamp every other field of the declaration wears — see ingraph-derive’s host module — and no exception is carved for this one. The visibility convention is about a declaration’s fields being read by the code emitted around them, and this field is the case that statement was written for.

§Panics

Never in practice: the tokens are this function’s own, and the only way they fail to parse as a named field is a change to this line.

Source

pub fn emitted_methods(&self) -> Vec<Emitted>

Every method this emission declares, in EMISSION ORDER, for the front end that has to refuse a collision before an expansion lands two of one name in a scope its author cannot edit.

The FIXED names are here for the reason a declaration’s derived ones are: a field called key reaches key_ref, and a copy field called new reaches new. Neither is a near miss — both are the emitted name exactly — so both are refused at the declaration rather than left to be a duplicate definition inside the expansion.

§EVERY name, and the ones this used to miss are the reason it says so

The list once held the constructor, the borrowed key and the accessor families, and the whole read-and-write surface below them was absent. Each absence was the same defect: a copy field called fan_title beside a fanout-marked title gives the index two fan_title, a field called retrieve_keys gives it two of those, and E0592 reports each of them at #[ingraph::fulltext(…)] — a span the author cannot edit, in a message that never names the field. A table that knows about the accessors alone refuses the collisions it happens to have heard of and is silent about the rest, which reads as a rule that has been applied.

§ONE OWNER, and an impl written inside the anonymous const is not a smaller scope

Every method here lands on the DECLARATION’s own type, which is why they all carry Owner::Record. The retrieve face is emitted inside the expansion’s anonymous const and the fan door at module scope, and that difference buys nothing: an inherent impl is global whatever block it was written in, so the two impls’ names share one namespace and collide with each other exactly as they collide with the carrier’s.

The order is the EMITTER’s own walk — see emit — so a front end reporting a collision can name the earlier of the two as the one already there. It is pinned against the emission itself by tests::the_enumeration_names_exactly_the_methods_the_emission_declares, rather than maintained by hand.

Source

pub fn emitted_types(&self) -> Vec<Declared>

Every TYPE this emission declares into the DECLARING SCOPE, in EMISSION ORDER — the markers, which are the whole of what a derived index puts in the type namespace beside the item its author wrote.

RecordModel::emitted_types’ argument, one family over: the front end refuses a declaration whose emitted types collide, and it asks HERE which those are rather than keeping a list of its own.

§WHY a derived index needs this at all, when its markers are minted rather than named

No word renames either of these, so the collisions are not a rename landing on a neighbour — they are the JOIN. A marker is <Index><Field><Engine> in upper camel case, and camel case has no separator: field a × engine b_c and field a_b × engine c both mint <Index>ABC. The election markers are <Index>By<Field> and stand in the same scope, so field by × engine image mints exactly the marker of an election on image.

The durable slot NAME has the same three parts and does NOT have the problem — see Slot::name, which joins with __ for precisely this reason and is test-pinned.

§The boundary-preserving JOIN was measured against the refusal, and lost on two counts

A TYPE cannot take that separator. <Index>__a__b_c is not upper camel case, so every marker would arrive under non_camel_case_types in a crate that never wrote it — the cost one_storage_marker already spends allows on, paid here on names the WIRING spells rather than on a hidden one. And spell them it does: SlotHandle<E, SearchDocumentTitleTantivy> and the lanes over it are some eighty sites across this workspace, several of them compile_fail goldens whose text IS the assertion.

And it would not close the class. The election markers camel-join too, so elections on image_1 and image1 mint one <Index>ByImage1 whatever the slot markers do. A respelling buys one of the three collisions and leaves the other two live — under an error code that would then look handled, which is the failure the whole-fix constraint was written against.

So the name stays and the collision is REFUSED at the declaration, which is the road that leaves the author’s own tokens the thing that moves.

§The INDEX’s own name is not here, and cannot collide with one of these

A record adds its own name to this list because a rename can land on it. Nothing here can: every marker is the index’s name followed by at least one more camel-case segment, so <Index> itself is not in the set — and a name this enumeration invented would refuse a declaration for a clash that could not happen.

The order is the emitter’s own walk — elections, then slots — and it is pinned against the emission by tests::the_enumeration_names_exactly_the_types_the_emission_declares.

Source

pub fn numbers_of(&self, field: &Ident) -> Option<&FieldNumbers>

What the field wrote, or None where it wrote nothing — the ELECTION tier’s lookup.

Source

pub fn declared_ceiling(&self, field: Option<&Ident>) -> Option<NonZeroU32>

THE WALL FOR ONE ROUTE — the declared ceiling route_depth caps every fetch against.

Two tiers and no third: the ELECTION’s word where it wrote one, else the CONTAINER’s. There is no framework default and there never will be one — an absent wall is the AUTHOR’S INFORMED OPENNESS (#293-B), and a number invented on their behalf would be the framework deciding what a deployment may afford.

field is None at the grains that are not one election’s — the full-text tier’s unsuffixed subject — where the container’s word is the whole chain.

Source

pub fn declared_streams(&self, field: Option<&Ident>) -> Option<NonZeroU32>

THE STREAM GUARD FOR ONE ELECTION — how many query vectors one request may ask its _with road with, or None where no tier wrote a guard.

declared_ceiling’s twin on the other protective axis, resolved the same way and for the same reason: the ELECTION’s word where it wrote one, else the CONTAINER’s, and no third step — a word written closer to the door is the more specific statement of the same rule, and an unwritten guard is NO guard rather than a number this crate invented.

It is spent in points_binding and nowhere else, which is the ruled scope: the guard is over an m a REQUEST states, and the only road asked with one is the _with question road.

Source

pub fn wall(&self, field: Option<&Ident>) -> TokenStream

THE WALL, AS AN EMITTED route_depth READS IT — the token that fills the second argument every fetch resolves through.

Option::as_ref over a fresh Option<NonZeroU32> rather than a hoisted const, and the shape is the borrow’s: the callee takes Option<&NonZeroU32>, the temporary lives to the end of the let statement the call sits in, and route_depth hands back an owned number — so nothing outlives the statement and no item has to be minted in the emitted body’s scope.

None where no tier declared one, which is the ::core::option::Option::None every site spelled while the word did not exist — so a declaration that writes nothing expands to exactly the tokens it expanded to before, and the word is purely additive.

Source

pub fn wire_first(&self, kind: GraphqlKind, field: Option<&Ident>) -> NonZeroU32

THE WIRE DEFAULT — the literal one election’s first: argument publishes, resolved through the ruled chain and capped by the wall.

field-skin `first`  →  field `limit`  →  container-skin `first`  →  container `limit`  →  20

The order is Q6a’s verbatim, and each step is the more specific statement of the same number: a skin’s word beats the bones at its own tier because it is written closer to the schema, and a field’s tier beats the container’s because it is written closer to the door. FRAMEWORK_LIMIT is the floor of the chain rather than a default anybody writes.

The WALL caps the answer, and that is not decoration: a default published above the ceiling would be a schema promising a page size the fetch silently cuts, which is the one thing an SDL literal must not be able to do.

Source

pub fn pool_depth(&self, kind: GraphqlKind, field: Option<&Ident>) -> NonZeroU32

THE POOL DEPTH a fold’s streams are fetched at when a request names none — the declared half of Q6b’s chain.

(request depth)  →  field `depth`  →  container `depth`  →  the whole limit chain

The first step is the REQUEST’s and is therefore the resolver’s, not a declaration’s: what this answers is everything below it, which is what a resolver falls to when the request deferred. Falling to the limit chain rather than to a depth of its own is the same statement Route::depth’s None makes one grain up — as deep as the answer is wide — and it keeps an undepthed world byte-identical to the one before the knob existed.

Trait Implementations§

Source§

impl Clone for IndexModel

Source§

fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl Debug for IndexModel

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.