querycensus

package
v0.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 4, 2026 License: Apache-2.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func AccessorPathCensus 

func AccessorPathCensus() [values.AccessorPathClassCount]int

AccessorPathCensus reports the class vector.

func AccessorPathDottedOrigins 

func AccessorPathDottedOrigins() []string

AccessorPathDottedOrigins returns the captured producer stacks.

func AccessorPathDottedWitnesses 

func AccessorPathDottedWitnesses() map[string]int

AccessorPathDottedWitnesses returns a copy of the witness set.

func AssertAccessorPathCensus 

func AssertAccessorPathCensus(w io.Writer, gates *AccessorPathGates) bool

AssertAccessorPathCensus checks the process census against its gates.

func AssertDottedLegQualifierCensus 

func AssertDottedLegQualifierCensus(w io.Writer, floors *DottedLegQualifierFloors) bool

AssertDottedLegQualifierCensus checks the census's hard zeros and its floors.

There are TWO hard zeros and they are different failures of the same table.

MATCH-ALIAS-DIFFERS: a leg matched on its OWN BINDING text while stating a different identity. That is the leg table having two spellings that disagree, resolved by the weaker one — the same contradiction the seed-window census refuses, seen through the one channel that cannot be re-keyed. A leg matched through its scan TABLE name is a different fact and has its own class; the zero would be unsatisfiable if the two were folded together, which is what the first measurement did. It is worth asserting HERE precisely because this reader will keep matching on text until its counterparty carries parsed segments: the guarantee that the text it matches names the leg the identity names is all that holds the channel together in the meantime.

MATCH-NO-ALIAS: a leg matched and states NO identity at all. This class was documented as blocking from the day it was written and was never gated, so its zero was a sentence rather than a check. It is the same defect the seed-window authority now declines on (an Alias-less leg files under the zero identifier and a second one displaces it), seen from the reader side: the leg table carries an entry whose identity nothing can compare, so the day the counterparty carries segments this leg has nothing to be matched against and the conversion silently loses it. Fix the PRODUCER; the two documented text boundaries that mint a leg from a string both set Name and Alias from that one string, so a leg reaching here without an identity came from neither.

func AssertDottedRowTypeProducerCensus 

func AssertDottedRowTypeProducerCensus(w io.Writer, floor *DottedRowTypeProducerFloor) bool

AssertDottedRowTypeProducerCensus checks the process census against a floor.

func AssertDottedWitnessAttribution 

func AssertDottedWitnessAttribution(w io.Writer, floors *DottedWitnessFloors) bool

AssertDottedWitnessAttribution checks both floors and the owner-collision zero.

func AssertFieldValueMintCensus 

func AssertFieldValueMintCensus(w io.Writer, gates *FieldValueMintGates) bool

AssertFieldValueMintCensus checks the process census against its gates.

func AssertLegColumnProvenanceCensus 

func AssertLegColumnProvenanceCensus(w io.Writer, floors *LegColumnProvenanceFloors) bool

AssertLegColumnProvenanceCensus checks the census's partition, its one zero and its population floors, and reports whether it failed.

The partition is the point: every share this census prints is a share of Calls, and a share only means something if the shares add up. The zero is DottedHitIdentityDiverged — a leg whose text and whose stated identity name different things, resolved by the text. That is not a residue to shrink, it is a contradiction: two keys for one leg, disagreeing, with only the weaker one consulted.

floors is nil when the run is NARROWED, exactly as its siblings do it: the floors describe a whole-suite population, and a -test.run selecting tests that never adapt a leg row reaches this reader zero times. The partition and the zero still run — they hold over any population, which is precisely why they are not a proof on their own.

func AssertLegIdentityCensus 

func AssertLegIdentityCensus(w io.Writer, floors map[values.LegIdentitySite]int64) bool

AssertLegIdentityCensus checks the census and reports whether it failed.

The ZERO assertions hold over ANY population — a fold-only pair, a diverged text/identity pair, an unstated identity, a RETIRED-VERDICT divergence, or a mixed instrument is a defect whether the corpus was one query or the whole suite — so they run always. That is FIVE, and callers must enumerate all five when they announce what a narrowed run still checks: an enumeration that omits the retired-verdict zero omits the one assertion that measures the conversion itself, which is the reason this census exists. Only the population FLOORS describe a particular corpus, and those are checked only for the sites the caller supplies: pass nil to assert the zeros over a narrowed run. Skipping the zeros along with the floors is how a filtered invocation used to report "floors not checked" while quietly also not checking the five things that are always checkable.

func AssertLegIdentityCensusWith 

func AssertLegIdentityCensusWith(w io.Writer, exp LegIdentityExpectations) bool

AssertLegIdentityCensusWith is AssertLegIdentityCensus with the zero-side guards a corpus may declare. See LegIdentityExpectations.

func AssertMergeSlotTypingCensus 

func AssertMergeSlotTypingCensus(w io.Writer, c MergeSlotTypingCounts, floor int) bool

AssertMergeSlotTypingCensus checks the census against `floor` slots, reports its reasoning to w, and returns whether it FAILED.

The polarity matches its siblings and the censusGate contract (census_gate_reporting_test.go): run returns FAILED, not OK. Getting it backwards makes a clean census report as a failure, which is how this was caught — the gate fired on a run reporting 22,362 slots with a holding partition and zero untyped. That total is one SAMPLE of a population that moves with memo exploration order (~22.4k; see positional_merge.go), which is why the floor below is an order of magnitude under it rather than an equality.

Two directions, and they are not the same alarm. The PARTITION identity going wrong means the instrument miscounts, so every share it reports is meaningless. UNTYPED going non-zero means a live slot lost its row type, which is the silent zero-rows defect. The floor guards the third case: a collapsed denominator makes `Untyped == 0` true for the wrong reason.

func AssertNameSplitCensus 

func AssertNameSplitCensus(w io.Writer, floors *NameSplitFloors) bool

AssertNameSplitCensus checks the census's hard zero and its floors, writing a report to w. Returns TRUE if anything FAILED — the convention its siblings on this path use, so a call site reading `if failed := ...` means what it says.

The HARD ZERO is SPLIT-QUALIFIED at both of THIS CENSUS's two sites — not at every splitter in Go — and it is asserted rather than floored because it is not a population to be kept healthy: it is the debt, and the whole claim of the projection-channel conversion is that production traffic no longer produces any AT THESE ARMS. A non-zero means either an un-migrated producer has started carrying dotted text where a triple belongs, or a machinery-minted label has acquired a dot. The failure text names both readings because the fix differs — and for the second it names the RULING rather than an escalation, since Java settles what a nameless projection output resolves to (nothing).

func AssertQualifierRecoveryCensus 

func AssertQualifierRecoveryCensus(w io.Writer, exp *QualifierRecoveryExpectations, corpus string) bool

AssertQualifierRecoveryCensus checks the census's hard zero, its saturation guards and its floors, writing a report to w. Returns TRUE if anything FAILED — the convention its siblings on this path use.

THE HARD ZERO IS **DIVERGED**, and it is the only zero this census asserts. That is a deliberate departure from its sibling, which asserts its debt bucket at zero: here MANUFACTURED is expected to be non-zero at several sites, because the whole finding is that these splitters exist and are reached. Asserting it at zero would either be false on the day it was written or would have to be relaxed into meaninglessness. What CANNOT be tolerated is a split that contradicts an identity the site was holding at the time — that is not debt, it is a wrong answer.

func AssertSeedWindowReaderCensus 

func AssertSeedWindowReaderCensus(w io.Writer, floors *SeedWindowReaderFloors) bool

AssertSeedWindowReaderCensus checks the two hard zeros and the floors.

floors is nil when the run is NARROWED (-test.run), exactly as its siblings do it: the zeros still run, over whatever population the filter reached, and at zero they hold vacuously.

func AssertSelectResultMintCensus 

func AssertSelectResultMintCensus(w io.Writer, floors *SelectResultMintFloors) bool

AssertSelectResultMintCensus checks the per-site partition, the untyped-QOV zero, and the per-site call floors.

func AssertUnnestLegMintCensus 

func AssertUnnestLegMintCensus(w io.Writer, executorDottedNames []string) bool

AssertUnnestLegMintCensus checks the one claim this census exists to keep honest: the names this mint produces and the names the EXECUTOR's dotted leg-column reader answers on are DISJOINT sets.

executorDottedNames is the dotted-hit name list from executor.LegColumnProvenanceDottedNames — threaded in rather than imported, because the executor package must not depend on the translator and this assertion needs both populations in one place.

WHY A DISJOINTNESS ASSERTION AND NOT A FLOOR. The booked acceptance condition for retiring the executor's dotted arm is that its hit count reaches zero, and that condition was booked against converting THIS mint. Disjointness is the measurement that says the condition is not reachable from here: the reader's live hits are produced somewhere else, so this mint could be deleted outright and the reader would answer exactly as often as before. A negative result of that shape is load-bearing — it is what reclassifies the conversion — so it is pinned rather than written down.

func AssertUnresolvedResultTypeCensus 

func AssertUnresolvedResultTypeCensus(w io.Writer, floors *UnresolvedResultTypeFloors) bool

AssertUnresolvedResultTypeCensus checks the process census against floors.

func ClassifyOrderingComparison 

func ClassifyOrderingComparison(
	c *OrderingComparisonCensus,
	left, right values.Value,
	bridge func(a, b values.Value) bool,
)

ClassifyOrderingComparison is recordOrderingComparison's body over an explicit census, so the classification can be exercised against a caller-owned struct instead of the package counters.

That separation is what makes the instrument testable at all. The counters are package-scoped and the corpus assertion built on them is a ZERO, which is exact under concurrent passes; a test asserting a NONZERO count has no such protection, and every test in this package must be safe to run in parallel. So the reachability pins — the ones that keep a zero from being a broken detector — pass their own census here and touch no global.

func DottedLegQualifierCensus 

func DottedLegQualifierCensus() ([dottedLegSiteCount][dottedLegClassCount]int, []string)

DottedLegQualifierCensus reports the per-site class matrix and the witnesses.

func DottedRowTypeProducerCensus 

func DottedRowTypeProducerCensus() (dotted, plain int, witnesses []string)

DottedRowTypeProducerCensus reports the counts and the distinct dotted row shapes the generic path derived.

func DottedWitnessAttribution 

func DottedWitnessAttribution() (attributed, unattributed []string, mintedCount int)

DottedWitnessAttribution reports, per observed name, whether it is attributed to a correlated-scalar seed inner leg BY IDENTITY.

func DumpAccessorPathCensus 

func DumpAccessorPathCensus(w io.Writer, label string)

DumpAccessorPathCensus renders the class vector.

func DumpFieldValueMintCensus 

func DumpFieldValueMintCensus(w io.Writer, label string)

DumpFieldValueMintCensus renders the census, with the partition check and the vacuity guard ahead of any zero-class claim.

func DumpOrderingBridgeDottedCensus 

func DumpOrderingBridgeDottedCensus(w io.Writer, label string)

DumpOrderingBridgeDottedCensus renders it, vacuity guard first.

func FieldValueMintCensus 

func FieldValueMintCensus() (total int, counts [fieldMintClassCount]int)

FieldValueMintCensus returns the independent total and the class vector.

func FieldValueMintOrigins 

func FieldValueMintOrigins() []string

FieldValueMintOrigins returns the captured producer stacks for the dotted classes.

func FormatDottedLegQualifierCensus 

func FormatDottedLegQualifierCensus() string

FormatDottedLegQualifierCensus renders the census for a harness to log.

func FormatDottedRowTypeProducerCensus 

func FormatDottedRowTypeProducerCensus() string

FormatDottedRowTypeProducerCensus renders the process census for a harness to log.

func FormatDottedWitnessAttribution 

func FormatDottedWitnessAttribution() string

FormatDottedWitnessAttribution renders the census for a harness to log.

func FormatLegColumnProvenanceCensus 

func FormatLegColumnProvenanceCensus() string

FormatLegColumnProvenanceCensus renders the census for a harness to log.

func FormatMergeSlotTypingCensus 

func FormatMergeSlotTypingCensus() string

FormatMergeSlotTypingCensus renders the tally for a harness report.

func FormatSeedWindowReaderCensus 

func FormatSeedWindowReaderCensus() string

FormatSeedWindowReaderCensus renders the per-site table for a harness to log.

func FormatSelectResultMintCensus 

func FormatSelectResultMintCensus() string

FormatSelectResultMintCensus renders the census for a harness to log.

func FormatUnnestLegMintCensus 

func FormatUnnestLegMintCensus() string

FormatUnnestLegMintCensus renders the census for a harness to log.

func FormatUnresolvedResultTypeCensus 

func FormatUnresolvedResultTypeCensus() string

FormatUnresolvedResultTypeCensus renders the process census for a harness to log.

func LegColumnProvenanceCensus 

func LegColumnProvenanceCensus() (legColumnProvenanceCounters, []string)

LegColumnProvenanceCensus reports the counters and the retained witnesses.

func LegColumnProvenanceDottedNames 

func LegColumnProvenanceDottedNames() []string

LegColumnProvenanceDottedNames returns the distinct COLUMN NAMES the dotted arm ANSWERED on — the qualified labels, not the witness prose.

It exists so a cross-population claim can be checked rather than eyeballed. The retirement condition booked for this reader is "the dotted-hit count goes to 0", booked against converting a mint in the TRANSLATOR; whether that is reachable depends on whether the names that mint produces are these names. Comparing the two sets needs both as data, and this census's witnesses are sentences.

func LegIdentityCensusEnabled 

func LegIdentityCensusEnabled() bool

LegIdentityCensusEnabled reports the gate state.

func LegIdentitySampleCap 

func LegIdentitySampleCap() int

LegIdentitySampleCap exposes that bound to the harnesses that gate on the witness sets.

A gate that walks a site's witnesses and clears each one against an allowlist is only as complete as the witness set: once the set is SATURATED, a further DISTINCT anomaly still increments the count but retains no witness, so the walk clears every witness it can see and the gate passes with a real divergence counted. Nothing about the count reveals that — a harness must compare the witness length against this cap and fail on saturation.

func LegIdentitySites 

func LegIdentitySites() []values.LegIdentitySite

LegIdentitySites returns every site, so a census pass can iterate without hard-coding the set.

func LegSiteNeitherMustBeZero 

func LegSiteNeitherMustBeZero(site values.LegIdentitySite) bool

LegSiteNeitherMustBeZero reports whether a site's Neither population is a FAILURE rather than ordinary traffic.

It is true exactly at the sites whose recorded pair is two spellings of ONE leg that must therefore denote the same thing: a leg's own (Name, Alias.Name()). Everywhere else the pair is a lookup against a leg it is allowed not to be, so Neither counts misses and only FoldOnlyEqual can indict.

LegSiteNLJPlanAlias is deliberately NOT here even though its pair is also two spellings of one leg: measured, the select's source-alias slice can carry a re-minted identifier while its quantifier keeps the user alias, and that divergence is the reason to prefer the quantifier rather than a reason to fail. See that site's comment.

The distinction is the reason FoldOnlyEqual == 0 was not enough on its own: a producer that stores Name "X" against Alias "Y" lands in Neither and leaves the fold-only count at zero while the text channel and the identity channel have diverged.

func LegSiteNeitherSampled 

func LegSiteNeitherSampled(site values.LegIdentitySite) bool

LegSiteNeitherSampled reports whether a site's Neither witnesses are worth retaining.

It is a SUPERSET of LegSiteNeitherMustBeZero, and the gap between them is the whole reason it is a separate predicate. Sampling used to be tied to the assertion, which meant the one site whose Neither = 12 motivated building the sampler — LegSiteNLJPlanAlias, whose Neither is deliberately not asserted because a stale source alias is a reason to prefer the quantifier rather than a failure — never sampled. The number that justified the instrument was the number the instrument could not explain.

The criterion is "is the pair two spellings of ONE leg?", not "is its zero enforced?": at those sites a Neither is diagnostic no matter what the gate does with it. Everywhere else Neither is per-row lookup traffic and sampling it would put a mutex in the row loop.

func NameSplitCensus 

func NameSplitCensus() ([nameSplitSiteCount][nameSplitClassCount]int, []string)

NameSplitCensus returns a snapshot of the counters and the debt witnesses.

func NoteFieldValueMint 

func NoteFieldValueMint(field string, baked bool)

NoteFieldValueMint records one FieldValue construction. The gate is the FIRST statement: disabled, this is one atomic load and a return.

func NoteOrderingBridgeDotted 

func NoteOrderingBridgeDotted(leftName, rightName string, answered bool)

NoteOrderingBridgeDotted records a bridge attempt in which at least one side carried a flat-dotted name. Gate first; disabled it is one atomic load.

func OrderingBridgeDottedCensus 

func OrderingBridgeDottedCensus() (int, [bridgeDottedClassCount]int, map[string]int)

OrderingBridgeDottedCensus returns the attempt total and class vector.

func QualifierRecoveryCensus 

func QualifierRecoveryCensus() ([values.QualRecSiteCount][values.QualRecClassCount]int, [values.QualRecSiteCount][values.QualRecClassCount][]string)

QualifierRecoveryCensus returns a snapshot of the counters and witnesses.

func QualifierRecoverySites 

func QualifierRecoverySites() []values.QualifierRecoverySite

QualifierRecoverySites returns every site, for callers that walk them.

func QualifierRecoveryWitnessCap 

func QualifierRecoveryWitnessCap() int

QualifierRecoveryWitnessCap exposes the cap so a harness can check saturation.

func RecordAccessorPathCall 

func RecordAccessorPathCall(class values.AccessorPathClass)

RecordAccessorPathCall counts one call's outcome. Sites reach it only via values.Census().

func RecordAccessorPathDottedWitness 

func RecordAccessorPathDottedWitness(name string)

RecordAccessorPathDottedWitness records the flat-dotted NAME that tripped the ratchet arm, so the producer can be found rather than guessed at. Sites reach it only via values.Census().

The name is exactly the string the guard refused to split, which is the whole point: it is the only artifact that distinguishes "a real nested path arrived lazy" from "a qualifier was concatenated onto a leaf".

func RecordDottedArmAnswer 

func RecordDottedArmAnswer(name string, owner values.CorrelationIdentifier)

RecordDottedArmAnswer records one name the executor's dotted arm answered on, with the OWNER correlation the reader held. Sites reach it only via values.Census().

First writer wins for the map, and a LATER, DIFFERENT owner for the same name is RECORDED as a collision rather than dropped. That is not tidiness: a name answered under two owners, one attributed and one not, would otherwise report as cleanly attributed and the second owner would never appear anywhere. The census's whole claim is per-name, so a name with two owners invalidates the claim for that name.

func RecordDottedLegQualifier 

func RecordDottedLegQualifier(site DottedLegSite, qual string, matchedAlias values.CorrelationIdentifier, matchedBinding string, lookup DottedLegLookup)

RecordDottedLegQualifier counts one qualifier-against-leg-table match. Sites reach it only via values.Census().

func RecordDottedRowTypeDerivation 

func RecordDottedRowTypeDerivation(fields []values.Field)

RecordDottedRowTypeDerivation counts ONE RecordType derivation by the generic record-constructor path, cut by whether the row it describes is the DOTTED `LEG.COL` shape. Sites reach it only via values.Census().

func RecordInnerScalarLegTitleAt 

func RecordInnerScalarLegTitleAt(producer values.InnerLegProducer, corr values.CorrelationIdentifier, title string)

RecordInnerScalarLegTitleAt registers one (correlation, title) pair minted for a correlated-scalar seed inner leg, naming the producer. Sites reach it only via values.Census().

func RecordLegIdentityComparison 

func RecordLegIdentityComparison(site values.LegIdentitySite, legName, corrName string)

RecordLegIdentityComparison records one leg-identity pair at a site: legName is the leg's stored text, corrName the counterparty correlation's own spelling.

Sites reach it only via values.Census(), so the disabled path costs one atomic load and no argument evaluation.

func RecordLegIdentityConversion 

func RecordLegIdentityConversion(site values.LegIdentitySite, leg, corr values.CorrelationIdentifier, retiredVerdict bool)

RecordLegIdentityConversion is recordLegIdentityPair plus the acceptance test the conversion needs: retiredVerdict is what the predicate this site USED TO evaluate says about this same pair, and a disagreement with SameLeg is counted and witnessed.

Every converted site must use this rather than recordLegIdentityPair while the migration is open. Computing the retired predicate at the site costs a string compare inside the census gate — production never evaluates it — and it is what turns "the conversion is representation-only" from three inferences chained across separate zero counts into one measurement of the decision itself. The retired predicates are not uniform (two sites compared exact text, two upper-folded one side), so no single central rule could stand in for them; each site states its own, verbatim.

Sites reach it only via values.Census().

func RecordLegIdentityLeg 

func RecordLegIdentityLeg(leg values.RecordTypeLeg)

RecordLegIdentityLeg records a leg's two spellings against each other at the text-vs-identity divergence site. Every reader that walks a leg calls it, so the population is every leg any consumer looked at.

Sites reach it only via values.Census().

func RecordNameSplit 

func RecordNameSplit(site NameSplitSite, class NameSplitClass, name string)

RecordNameSplit records one resolution decision at a splitting arm. `name` is the rendered field name the arm was handed; it is used only for the witness list of the debt bucket, so a regrowth arrives with the spelling that caused it rather than only a count.

func RecordQualifierRecovery 

func RecordQualifierRecovery(site values.QualifierRecoverySite, class values.QualifierRecoveryClass, name, identity string)

RecordQualifierRecovery records ONE resolution decision at a dark splitter.

`name` is the rendered name the site was handed and `identity` is the structured counterparty it had in hand (empty when it had none). Both go into the witness so a regrowth arrives with the pair that caused it — for DIVERGED in particular, the count alone cannot say which side is wrong.

func RecordSeedWindowLookup 

func RecordSeedWindowLookup(site values.SeedWindowSite, found bool)

RecordSeedWindowLookup is the common shape: found or not.

func RecordSeedWindowLookupOfKind 

func RecordSeedWindowLookupOfKind(site values.SeedWindowSite, found bool, kind values.LegKind)

RecordSeedWindowLookupOfKind is the kind-aware counterpart of RecordSeedWindowLookup, for the readers that dispatch on the window kind.

func RecordSeedWindowRead 

func RecordSeedWindowRead(site values.SeedWindowSite, class values.SeedWindowReadClass)

RecordSeedWindowRead counts one keyed read of a seed-window map. Sites reach it only via values.Census().

func RecordSelectResultMint 

func RecordSelectResultMint(site values.SelectResultMintSite, rv values.Value)

RecordSelectResultMint counts ONE select-result-value construction and registers its identity.

The gate is the FIRST statement and it returns: with the census off this site must cost one atomic load and nothing else. The shape spelling below is a Sprintf per select expression built, which is planning-path work nothing consumes when the census is disabled.

func RecordUnnestLegMintArm 

func RecordUnnestLegMintArm(site values.UnnestLegMintSite, arm values.UnnestLegMintArm)

RecordUnnestLegMintArm counts ONE arm taken at a seed-tested branch point. Sites reach it only via values.Census().

func RecordUnnestLegMintBranchReached 

func RecordUnnestLegMintBranchReached(site values.UnnestLegMintSite)

RecordUnnestLegMintBranchReached counts ONE arrival at a seed-tested branch point, BEFORE any arm is chosen. Sites reach it only via values.Census().

It is the INDEPENDENT denominator for the arm matrix. Summing the arms instead is true by construction and cannot see an arm that was added without a counter — see the values.UnnestLegMintArm doc.

func RecordUnnestLegMintCall 

func RecordUnnestLegMintCall(site values.UnnestLegMintSite)

RecordUnnestLegMintCall counts ONE invocation of the name-keyed rebase at a site, whether or not it rewrites anything. Sites reach it only via values.Census().

Counted separately from the NAMES because a site can be reached constantly and mint nothing (no reference in the predicate names an outer leg), and the two facts have opposite meanings for a conversion: the first says the arm is live, the second says it produces the text a downstream reader decides on.

func RecordUnnestLegMintName 

func RecordUnnestLegMintName(site values.UnnestLegMintSite, name string)

RecordUnnestLegMintName counts ONE minted qualified name at a site. Sites reach it only via values.Census().

func RecordUnnestLegOrdinalTwinCall 

func RecordUnnestLegOrdinalTwinCall()

RecordUnnestLegOrdinalTwinCall counts ONE invocation of rebaseUnnestOuterLegPredicateOrdinal, from any caller.

It is the DENOMINATOR the per-arm counts are read against, and it is counted inside the twin rather than summed from the arms for the reason the fold-step1 census states about its own independent denominator: a sum over the recorded arms is true by construction and cannot see a caller that reaches the twin without passing a branch point this census instruments.

The twin has THREE call sites: the buried `seedWindowed` arm, the chained `ordinalSeed` arm, and `bakeInnerExistsPredicateOrdinal`. This census instruments the first two directly as ARMS; the third is reached only through the two planTimeBake arms, so its calls are attributed to no arm and show up as the gap between this total and the summed ordinal-twin arms. (The two planTimeBake arms are two callers of `bakeInnerExistsPredicateOrdinal`, which is one caller of the twin.)

func ReportLegIdentityCensus 

func ReportLegIdentityCensus(w io.Writer, label string)

ReportLegIdentityCensus dumps every site's counts and witnesses. It reports unconditionally — a narrowed corpus still has numbers worth seeing, it just has no floors to check.

func ResetAccessorPathCensus 

func ResetAccessorPathCensus()

ResetAccessorPathCensus clears the counters.

func ResetDottedLegQualifierCensus 

func ResetDottedLegQualifierCensus()

ResetDottedLegQualifierCensus clears the counters.

func ResetDottedRowTypeProducerCensus 

func ResetDottedRowTypeProducerCensus()

ResetDottedRowTypeProducerCensus clears the counters.

func ResetDottedWitnessAttribution 

func ResetDottedWitnessAttribution()

ResetDottedWitnessAttribution clears the census.

func ResetFieldValueMintCensus 

func ResetFieldValueMintCensus()

ResetFieldValueMintCensus clears the counters.

func ResetLegIdentityCensus 

func ResetLegIdentityCensus()

ResetLegIdentityCensus zeroes every site's counts and witnesses.

func ResetMergeSlotTypingCensus 

func ResetMergeSlotTypingCensus()

ResetMergeSlotTypingCensus zeroes the tally.

func ResetNameSplitCensus 

func ResetNameSplitCensus()

ResetNameSplitCensus clears the counters. For tests that measure one shape.

func ResetOrderingBridgeDottedCensus 

func ResetOrderingBridgeDottedCensus()

ResetOrderingBridgeDottedCensus clears the counters.

func ResetOrderingComparisonCensus 

func ResetOrderingComparisonCensus()

ResetOrderingComparisonCensus zeroes every site's counts.

It exists because these counters are PACKAGE-scoped, and this package has learned what that costs: ReachabilityCollector's header records a corpus tally that read 3x its true value because sibling tests planned the same corpus in parallel. The same hazard applies here, with one difference that makes the package scope tolerable — the assertion built on these counts is a ZERO, and a zero over a sum of non-negative terms is exact no matter how many extra corpus passes contribute to it. A concurrent pass can only make the assertion FAIL, never falsely pass.

The absolute TOTALS have no such protection: they are a lower bound unless the census ran alone. Reset before a pass and run that pass with -run isolation if the totals themselves are the artifact you need.

func ResetQualifierRecoveryCensus 

func ResetQualifierRecoveryCensus()

ResetQualifierRecoveryCensus clears the counters. For tests measuring one shape.

func ResetSeedWindowReaderCensus 

func ResetSeedWindowReaderCensus()

ResetSeedWindowReaderCensus clears the counters.

func ResetSelectResultMintCensus 

func ResetSelectResultMintCensus()

ResetSelectResultMintCensus clears the counters and the origin registry.

func ResetUnnestLegMintCensus 

func ResetUnnestLegMintCensus()

ResetUnnestLegMintCensus clears the counters.

func ResetUnresolvedResultTypeCensus 

func ResetUnresolvedResultTypeCensus()

ResetUnresolvedResultTypeCensus clears the process counters. Present so a test can drive the REAL recorder — recordResultTypeRead, by name — rather than a local copy of its body, which is the mutation a copy would survive.

func SeedWindowReaderCensus 

func SeedWindowReaderCensus() [values.SeedWindowSiteCount][values.SeedWindowReadClassCount]int

SeedWindowReaderCensus reports the per-site class matrix.

func SelectResultMintOriginOf 

func SelectResultMintOriginOf(rv values.Value) (values.SelectResultMintSite, bool)

SelectResultMintOriginOf reports the site that MINTED rv, and whether any did. Sites reach it only via values.Census().

func SetLegIdentityCensusEnabled 

func SetLegIdentityCensusEnabled(on bool)

SetLegIdentityCensusEnabled turns the census on or off. It is OFF in every production path and in every test but the corpus census pass; when off, each comparison pays one relaxed atomic load.

The gate matters more here than for the planner-side censuses: two of these sites are on the PER-ROW executor path, so an always-on counter would put a contended atomic increment in the row loop.

func SetOrderingComparisonCensusEnabled 

func SetOrderingComparisonCensusEnabled(on bool)

SetOrderingComparisonCensusEnabled turns the census on or off. It is OFF in every production path and in every test but the corpus census, which needs the counts and is the only reader; when off, each comparison pays one relaxed atomic load.

func UnnestLegMintArms 

func UnnestLegMintArms() ([values.UnnestLegMintSiteCount][values.UnnestLegMintArmCount]int, [values.UnnestLegMintSiteCount]int, int)

UnnestLegMintArms reports the per-site arm matrix and the twin's independent total.

func UnnestLegMintCensus 

func UnnestLegMintCensus() (calls, mints [values.UnnestLegMintSiteCount]int, names []string)

UnnestLegMintCensus reports per-site calls, per-site mints, and the distinct minted names.

func UnresolvedResultTypeCensus 

func UnresolvedResultTypeCensus() (map[string]int, map[string]int)

UnresolvedResultTypeCensus reports a SNAPSHOT of the counters as two maps, resolved and unresolved, keyed by deciding site.

Types

type AccessorPathClassLabel 

type AccessorPathClassLabel values.AccessorPathClass

AccessorPathClassLabel prints a values.AccessorPathClass.

func (AccessorPathClassLabel) String 

func (c AccessorPathClassLabel) String() string

type AccessorPathGates 

type AccessorPathGates struct {
	MinTotal         int
	MaxDeclineDotted *int
}

AccessorPathGates are the populations this census refuses to let move silently. It is named Gates rather than Floors, as its siblings are, because the two arms guard OPPOSITE directions on different populations.

  • MinTotal guards VACUITY, on the denominator. A ceiling over zero observations passes perfectly while measuring nothing, and a green from an empty set is this repo's dominant false positive. Nothing else here may be read without it.

  • MaxDeclineDotted is the GROWTH ceiling on the ratchet arm (AccessorPathDeclineDotted), and growth is the ONLY alarm direction it has.

THE DIRECTION HERE INVERTED, and the history is kept because a guard whose expected value moved is exactly the one that gets silently relaxed instead. The arm carried 4 declines: two RENDERED EXPLAIN LABELS (`q$N.AID#0`) minted by RecordQueryInMemorySortPlan.HintOrdering re-entering a display string as an identity, and `N.SK` — a genuinely NESTED path (struct column `n`, field `sk`, from `GROUP BY n.sk`) the resolver FUSED into one flat Field, which is the real `addr.city` versus `T.city` ambiguity this guard was written for. The rendered ones died with the advertiser fix. `N.SK` then died too, at its PRODUCER: a nested-path GROUP BY key is now rejected before it reaches the planner.

So ZERO is the steady state, a collapse floor on this arm would be unsatisfiable, and the event to watch for is the arm coming BACK — by the lazy render returning, or by the nested-path GROUP BY rejection being relaxed without the resolver keeping the path segmented. The floor is not deleted so much as SUPERSEDED: MinTotal still catches the instrument dying, which is the thing a collapse floor on the arm would otherwise have been covering.

A nil *AccessorPathGates is a no-op, which is the shape a narrowed run needs for MinTotal — a whole-corpus population claim. The ceiling is exact under any filter (a subset cannot exceed the whole), so it survives narrowing and is checked whenever gates is non-nil; MaxDeclineDotted nil leaves it unchecked.

type BridgeDottedClass 

type BridgeDottedClass int
const (
	// BridgeDottedAnsweredFalse: at least one side was flat-dotted and the bridge
	// reported NOT the same column. The suspect class.
	BridgeDottedAnsweredFalse BridgeDottedClass = iota
	// BridgeDottedAnsweredTrue: at least one side was flat-dotted and the bridge
	// matched anyway — two identical renderings.
	BridgeDottedAnsweredTrue
)

func (BridgeDottedClass) String 

func (c BridgeDottedClass) String() string

type DottedLegClass 

type DottedLegClass int

DottedLegClass is one call's bucket. The six partition every call. 

const (
	// DottedLegMatchAliasIsQualifier: a leg matched and its stated Alias is
	// EXACTLY the qualifier text. The leg table can serve an identity; the
	// lookup still cannot, having none to offer.
	DottedLegMatchAliasIsQualifier DottedLegClass = iota
	// DottedLegMatchAliasDiffers: a leg matched by FOLDED text and its stated
	// Alias is not that text. Minting from the qualifier would forge an
	// identifier the leg disagrees with — this is the population that would make
	// a text→identifier mint wrong rather than merely redundant.
	DottedLegMatchAliasDiffers
	// DottedLegMatchNoAlias: a leg matched and states no identity at all.
	DottedLegMatchNoAlias
	// DottedLegMatchViaTableName: a leg matched on a qualifier that is NOT its
	// binding — the scan TABLE name, registered as a second addressing route so
	// `FROM PA AS "s"` still answers `PA."ID"` (the ordinal leg type's RecordName
	// contract). The identifier such a qualifier would mint is by DESIGN not the
	// quantifier's, so this population is the reason its map cannot be re-keyed
	// by identity even in principle: one of its two key kinds names a table, and
	// a table is not a quantifier.
	//
	// It is counted apart from MATCH-ALIAS-DIFFERS rather than folded into it
	// because the two look identical at the reader — a qualifier and a leg alias
	// that disagree — and mean opposite things. Folding them would have reported
	// a live contradiction where there is a documented feature, and the census
	// did exactly that before this class existed.
	DottedLegMatchViaTableName
	// DottedLegAmbiguousQualifier: the qualifier named MORE THAN ONE leg and the
	// layout map POISONED that key (`layouts[key] = nil`) so nothing bakes
	// through it. Two legs sharing an alias, or two legs scanning one table under
	// the table-name addressing route.
	//
	// It is a fifth thing, not a flavour of noMatch, and folding it into noMatch
	// is what this class fixes. The census recorded its call BEFORE the `lay ==
	// nil` bail, and a poisoned key and an absent one are the same nil at that
	// point — so "no leg carried the qualifier" was reported for a qualifier
	// carried by two. The two mean opposite things about the leg table: absent is
	// a reference the table does not describe, ambiguous is a table that
	// describes it twice and refuses to choose. Only the second is a fact about
	// how much this channel is being asked to do.
	DottedLegAmbiguousQualifier

	// DottedLegNoMatch: no leg carried the qualifier. Not a name decision — the
	// reference falls through unbaked.
	DottedLegNoMatch
)

func (DottedLegClass) String 

func (c DottedLegClass) String() string

type DottedLegLookup 

type DottedLegLookup int

DottedLegLookup is what the READER's own map read produced, before any question about the leg it found. It is threaded in rather than inferred from the matched leg, because two of its three values arrive at the reader as the same nil: a qualifier with no entry and a qualifier whose entry was POISONED for ambiguity are indistinguishable once the map read is over, and they mean opposite things. 

const (
	// DottedLegLookupMiss: the layout map/leg table has no entry for this
	// qualifier.
	DottedLegLookupMiss DottedLegLookup = iota
	// DottedLegLookupAmbiguous: an entry exists and is POISONED — two legs claim
	// the qualifier, so nothing may bake through it.
	DottedLegLookupAmbiguous
	// DottedLegLookupHit: exactly one leg carried the qualifier.
	DottedLegLookupHit
)

type DottedLegQualifierFloors 

type DottedLegQualifierFloors struct {
	Calls [dottedLegSiteCount]int
}

DottedLegQualifierFloors is the minimum population each site must report over a whole suite run.

Same reason as every floor on this path, and it bites harder here than usual: the findings this census produces are "the MATCH-ALIAS-DIFFERS population is empty" and "the MATCH-NO-ALIAS population is empty", and an unreached site prints both identically to a site measured clean. A site left at 0 is UNFLOORED and that is a statement about the corpus, not an omission.

type DottedLegSite 

type DottedLegSite int

DottedLegSite is one translator reader that matches a name-split qualifier against a leg table. 

const (
	// DottedLegSiteFlatColumnBake is query.bakeFlatRefsAgainstColumns' dotted
	// arm: qualifier → leg window over the flat output column list, leaf →
	// first match within the window. Its leg table comes from
	// expressionOutputLegs or from the wholeRowLegFor TEXT-BOUNDARY mint.
	DottedLegSiteFlatColumnBake DottedLegSite = iota

	// DottedLegSiteLegQOVBake is query.bakeDottedRefsToLegQOV's MULTI-ForEach
	// per-leg layout lookup: qualifier → the leg's own layout, leaf → an ordinal
	// in that leg's OWN column domain. Its layouts are keyed by upper-folded text
	// while each layout carries the quantifier's identity, so it is the same
	// held-apart namespace pair the seed windows had.
	DottedLegSiteLegQOVBake
)

func (DottedLegSite) String 

func (s DottedLegSite) String() string

type DottedRowTypeProducerFloor 

type DottedRowTypeProducerFloor struct {
	Derivations int
	Dotted      int
}

DottedRowTypeProducerFloor carries the two populations this census refuses to let collapse silently. They are DIFFERENT claims and neither can stand in for the other.

  • Derivations floors the TOTAL traffic (dotted + plain) and guards the INSTRUMENT. A run reporting no derivations at all is reporting a broken counter, not a quiet corpus. `plain` is what floors it in practice: `RecordConstructorValue.Type()` is called by any query that constructs a record, and both full-corpus readings clear 100 by three orders of magnitude.

  • Dotted floors the FINDING, and it is the reason this struct has two fields. The finding is "DOTTED is not zero" — that `RecordConstructorValue.Type()` IS a producer of the `LEG.COL`-shaped row, which places the leg-table population on this path (RFC-212 §1.1, §3.5). Derivations cannot watch that: plain outnumbers dotted about 230:1 (157699 to 681), so DOTTED could return to zero and the total floor would still pass by three orders of magnitude.

ALARM DIRECTION ON Dotted: COLLAPSE, because the expected value is non-zero, so a floor rather than a hard zero guards it. A return to zero means either the corpus stopped reaching the dotted path or the discriminator broke; in both cases §1.1's placement decision has quietly lost the evidence it rests on while the build stays green.

If a later change makes zero legitimate again — the dotted `LEG.COL` row retired, the executor's dotted arm gone — the direction INVERTS with it: the alarm becomes growth and the guard becomes a hard zero. Reconcile it with the new expected value; do not lower it to whatever the run produced, and do not delete it, which would leave the revival unwatched.

A nil floor, and equally a zero-valued one, is a NO-OP by construction: the shape a `-test.run`-narrowed corpus needs, where a whole-run population claim has nothing it can honestly decide.

type DottedWitnessFloors 

type DottedWitnessFloors struct {
	// Observed floors the dotted-arm names. A partition over an empty observed
	// population reads exactly like a decided one.
	Observed int
	// Minted floors the registrations. A NOT-attributed finding is load-bearing
	// only when the producers minted titles on that run, so the instrument was
	// demonstrably live. A run minting ZERO reports NOT attributed for every
	// name, vacuously, and looks identical to a real refutation.
	Minted int
}

DottedWitnessFloors are the two populations that must be non-trivial for this census's finding to mean anything.

type FieldMintClass 

type FieldMintClass int

FieldMintClass is one lazy mint's bucket. These partition the mints this census sees, and the partition is checked against an independent total. 

const (
	// FieldMintLazyBare: a lazy Field with a plain, undotted name. The ordinary
	// plan-time carrier — a match candidate or an ordering hint.
	FieldMintLazyBare FieldMintClass = iota

	// FieldMintLazyDotted: a lazy Field containing '.' but no '#'. Ambiguous
	// between a real nested path (addr.city) and an alias-qualified leaf
	// (T.city), which is the ambiguity AccessorNamePath refuses to resolve.
	FieldMintLazyDotted

	// FieldMintLazyExplainRendered: a lazy Field containing BOTH '.' and '#' —
	// the shape explainValueOrdinals produces and nothing else does. This is the
	// sharp class. A name is data the planner resolves; an Explain rendering is
	// output. Feeding output back in as identity is a layering violation, not
	// merely a missing ordinal, and it is the one class whose non-zero is a
	// defect rather than debt.
	FieldMintLazyExplainRendered

	// FieldMintLazyEmpty: a lazy Field with no name at all.
	FieldMintLazyEmpty

	// FieldMintBaked: Resolved is non-nil, so the node carries an ordinal
	// identity and its Field is display only — the state the whole migration is
	// moving toward. Counted so the lazy classes have something to be a fraction
	// OF.
	FieldMintBaked
)

func ClassifyFieldMint 

func ClassifyFieldMint(field string, baked bool) FieldMintClass

ClassifyFieldMint is the pure classifier, split from the counter so it can be exercised without process-global state. A classification only reachable through a mutation is a classification no test can pin.

func (FieldMintClass) String 

func (c FieldMintClass) String() string

type FieldValueMintGates 

type FieldValueMintGates struct {
	MinTotal           int
	MaxTotal           *int
	MaxExplainRendered *int
}

FieldValueMintGates are the populations this census refuses to let move silently.

  • MinTotal guards VACUITY, against the INDEPENDENT denominator. A ceiling of zero over zero observed mints passes perfectly while measuring nothing; that green-from-an-empty-set is the failure this repo hits most.

  • MaxExplainRendered is the GROWTH ceiling on FieldMintLazyExplainRendered, the one class whose non-zero is a DEFECT rather than debt: a Field carrying both '.' and '#' is the shape explainValueOrdinals emits and nothing else does, so it is Explain OUTPUT fed back in as identity. Its whole measured population — 21,865 mints, all 64 captured origins on one line — came from RecordQueryInMemorySortPlan.HintOrdering minting a lazy FieldValue from SortKey.Field while SortKey.ValueExpr held the baked identity all along. That arm is gone; the expected value is 0, and there is no floor to pair with this ceiling because zero IS the steady state here.

  • MaxTotal is the RETIREMENT ceiling, and it is what a corpus sets once the lazy mint is gone from the tree rather than merely quiet. It supersedes MinTotal instead of sitting beside it: the two are opposite claims about the same population and a corpus asserts one or the other. Being a ceiling it survives narrowing, which a floor cannot — and a retirement is a fact about the TREE, so it must.

The PARTITION is checked unconditionally whenever gates is non-nil: a class vector that disagrees with the independently counted total means a mint took a path no arm classified, which is a bug in this census rather than a fact about the code — and it makes every number above it unreadable. It is exact under any filter, so it needs no floor to be honest.

A nil *fieldValueMintGates is a no-op, the shape a narrowed run needs for MinTotal. The ceilings and the partition survive narrowing (a subset cannot exceed the whole, and a sum of non-negative counters is exact under any filter), so all of them are checked whenever gates is non-nil.

type InnerLegProducerLabel 

type InnerLegProducerLabel values.InnerLegProducer

InnerLegProducerLabel prints a values.InnerLegProducer.

func (InnerLegProducerLabel) String 

func (p InnerLegProducerLabel) String() string

type LegCensusChannel 

type LegCensusChannel int32

LegCensusChannel is the namespace a site's recorded pairs live in.

It is set by whichever Record function the site calls and is never declared in a table, because a table is exactly what went wrong: the sites were DOCUMENTED as comparing identities while their instrument recorded text, and no mechanism noticed. A site that records in both namespaces reports LegChannelMixed, which the corpus gate treats as a failure — its numbers then describe neither comparison. 

const (
	// LegChannelNone is a site nothing recorded at.
	LegChannelNone LegCensusChannel = 0
	// LegChannelText is a site whose pairs are two strings, compared as text.
	LegChannelText LegCensusChannel = 1
	// LegChannelIdentity is a site whose pairs are two CorrelationIdentifiers,
	// classified the way SameLeg decides.
	LegChannelIdentity LegCensusChannel = 2
	// LegChannelMixed is a site that recorded in both — an instrument that cannot
	// be read.
	LegChannelMixed LegCensusChannel = 3
)

func (LegCensusChannel) String 

func (c LegCensusChannel) String() string

String names the channel for report and failure text.

type LegColumnProvenanceFloors 

type LegColumnProvenanceFloors struct{}

LegColumnProvenanceFloors is the population this census must report over a whole suite run — and it is now EMPTY, which is the reconciliation rather than an omission.

It used to floor two numbers, because the census's finding was a pair of small ones: the dotted arm answered four times in the whole corpus, all four with an identity available. A zero population satisfied that second half vacuously, satisfied the DottedHitIdentityDiverged zero vacuously, and satisfied the partition as 0 == 0 — so a census that stopped being driven reported exactly the shape of a census reporting good news, and at that scale "4" and "0" do not look different at a glance.

The reader has since been RETIRED, and the retirement is what inverts the guard. adaptLegPositional's permutation gather is its only driver, and that gather's own note said what would end it: "retiring this gather requires Go's seed to bake against the chosen physical leg layout the same way [Java does]". The exact-ordinal seed does that, so every leg row now passes positionalMatchesLegType and the gather — and this reader with it — is never entered. A floor on that population is unsatisfiable; the danger is REVIVAL, and that is asserted unconditionally in assertLegColumnProvenanceCounters.

The type stays so the gate keeps its narrowed-run shape (a nil floors pointer still means "the corpus was filtered"), and so a future population has somewhere to be floored.

type LegIdentityCensus 

type LegIdentityCensus struct {
	// Total is every leg/correlation pair the site examined.
	Total int64

	// ExactEqual is the pairs whose two spellings are byte-identical — the
	// population on which an exact and a folding comparison cannot disagree.
	ExactEqual int64

	// FoldOnlyEqual is the pairs that fold equal but are NOT equal. This is the
	// conversion delta, and it is the count that must be ZERO for a
	// folding-to-exact conversion to be free. A nonzero value means a leg is
	// stored under one spelling and looked up under another, which is a producer
	// defect: the fix belongs at whichever site normalizes, not in the
	// comparison.
	FoldOnlyEqual int64

	// Neither is the pairs that are different legs under either comparison — the
	// scan traffic every lookup pays walking to its own leg.
	Neither int64

	// FoldOnlySamples holds up to legIdentitySampleCap distinct "legName vs
	// corrName" witnesses from the FoldOnlyEqual population, so a nonzero count
	// names the offending pair instead of merely reporting a number.
	FoldOnlySamples []string

	// Unstated is the pairs where at least one side is the ZERO
	// CorrelationIdentifier. It exists only on the identity channel: SameLeg
	// declines an unstated identifier unconditionally (SameLeg(zero, zero) used to
	// be true, and two omissions agreeing is how a leg bound the wrong row), so
	// such a pair is neither a match nor an ordinary miss — it is a leg whose
	// identity was never sourced. Counting it apart keeps ExactEqual/FoldOnlyEqual/
	// Neither meaning what they say on the identity channel.
	//
	// The TEXT channel has no equivalent bucket: there, "" is just a string, and a
	// leg with no text is skipped by its producers before the comparison.
	Unstated int64

	// UnstatedSamples names the offending sides, same service as the other two
	// witness sets — an unstated identity is diagnosable only by which side is
	// blank and what the other one was.
	UnstatedSamples []string

	// NeitherSamples is the same service for the Neither population, and it is
	// collected at the sites where Neither is DIAGNOSTIC rather than traffic
	// (LegSiteNeitherSampled). At a genuine COMPARISON site Neither is the ordinary
	// scan cost every lookup pays walking to its own leg — a large, per-row
	// population whose witnesses say nothing and whose sampling would put a mutex
	// in the row loop. At the identity-PAIR sites the pair is two spellings of ONE
	// leg, so Neither means those two spellings name different things.
	//
	// This exists because it was needed: retyping the nested-loop join plan's leg
	// identities reported Neither = 12 over ~80k firings, and a bare 12 cannot be
	// diagnosed. That site is sampled for exactly that reason even though its
	// Neither is NOT asserted to be zero — the diagnosis is the point, and the site
	// whose number motivated the sampler was the one site the first form of it
	// skipped. The rule: a site whose pair is two spellings of one leg names its
	// witnesses, whether or not its zero is enforced.
	NeitherSamples []string

	// RetiredVerdictDivergent is the pairs on which the predicate the site USED TO
	// evaluate disagrees with the identity predicate it evaluates NOW. It is the
	// conversion delta measured DIRECTLY, and it is the only population that
	// answers the question the conversion actually raises.
	//
	// The three zeros above do not answer it, and reasoning from them is what let a
	// converted reader be reported clean. FoldOnlyEqual catches a match that became
	// a decline only when the retired predicate was exact-on-text; two of these
	// sites upper-FOLDED one side, so their retired predicate could match a pair
	// this one declines for a reason no fold-only count sees. And a DECLINE that
	// became a MATCH is invisible to every one of them — a leg whose identity is a
	// lowercase machine mint matches itself exactly while the retired
	// upper-folding predicate rejected it, and that pair lands in ExactEqual,
	// indistinguishable from a pair both predicates accepted.
	//
	// Zero here means the conversion is representation-only ON THIS CORPUS, which
	// is the claim the migration makes. A nonzero value names a shape whose row
	// binding changed and must be justified as a FIX with a test, not measured
	// away.
	RetiredVerdictDivergent int64

	// RetiredVerdictSamples names the divergent pairs, in the form
	// "leg vs corr (retired=match|decline)", so a nonzero count says which
	// direction flipped as well as where.
	RetiredVerdictSamples []string

	// Channel is which namespace the site recorded in — see LegCensusChannel. It
	// is observed, not declared, so a site whose instrument drifts away from its
	// comparison is reported instead of believed.
	Channel LegCensusChannel
}

LegIdentityCensus is one site's comparison population.

func LegIdentityCensusOf 

func LegIdentityCensusOf(site values.LegIdentitySite) LegIdentityCensus

LegIdentityCensusOf returns a site's counts.

The absolute totals are a LOWER BOUND unless the census ran alone: these counters are package-scoped, so a sibling test planning or executing the same corpus in parallel contributes to them. The assertion the census exists to support is a ZERO (FoldOnlyEqual), and a zero over a sum of non-negative terms is exact however many extra passes contribute — a concurrent pass can only make it FAIL, never falsely pass. Reset before a pass and isolate that pass if the totals themselves are the artifact needed.

type LegIdentityExpectations 

type LegIdentityExpectations struct {
	// Floors is the population each site must report over the UNFILTERED corpus.
	// Dropped under a -test.run filter, which is why it cannot carry a zero: a
	// guard that vanishes under narrowing cannot watch a revival.
	Floors map[values.LegIdentitySite]int64

	// DeclaredEmpty names sites this corpus MEASURED at zero although their
	// recorders still stand, mapped to why. A DISPLACED reader is the case: the
	// code is reachable in principle and this suite no longer routes through it.
	//
	// Checked in the STALE direction — a declared site reporting traffic FAILS,
	// so the declaration cannot outlive the condition that made it honest. The
	// check runs under a filter too, and safely: a narrowed run is a SUBSET, so
	// it cannot exceed a population the whole suite measured at zero.
	DeclaredEmpty map[values.LegIdentitySite]string

	// Retired names sites whose recorder has NO production caller at all, mapped
	// to why. Unlike DeclaredEmpty this is a fact about the TREE, so its failure
	// text tells the reader that something came back rather than that a corpus
	// moved.
	Retired map[values.LegIdentitySite]string
}

LegIdentityExpectations is what one CORPUS expects of the census. It exists because a site can sit at zero for three different reasons and they need three different guards — a floor watches for COLLAPSE, and once zero is the steady state the alarm INVERTS to growth.

type LegIdentitySiteLabel 

type LegIdentitySiteLabel values.LegIdentitySite

LegIdentitySiteLabel prints a values.LegIdentitySite.

func (LegIdentitySiteLabel) String 

func (s LegIdentitySiteLabel) String() string

type MergeSlotTypingCounts 

type MergeSlotTypingCounts struct {
	Typed     int
	Scavenged int
	Scalar    int
	Untyped   int
	Slots     int
}

MergeSlotTypingCounts is the census tally. The four classes must partition Slots; that identity is what makes a share of them meaningful.

func MergeSlotTypingCensus 

func MergeSlotTypingCensus() MergeSlotTypingCounts

MergeSlotTypingCensus returns the current tally.

type NameSplitClass 

type NameSplitClass int

NameSplitClass is one call's bucket. The three partition every call. 

const (
	// NameSplitSegmented: the parser's segment triple decided this node's
	// qualification. No rendered name was sliced.
	NameSplitSegmented NameSplitClass = iota

	// NameSplitQualified: a dot was found in a rendered name and the bytes
	// before it became a qualifier. THE DEBT POPULATION — the only bucket in
	// which a quoted `"A.B"` and a qualified `A.B` are the same input.
	NameSplitQualified

	// NameSplitBare: the fallback ran and found no dot, so no qualifier was
	// manufactured. Not debt; counted so a clean arm is distinguishable from a
	// dark one.
	NameSplitBare
)

func (NameSplitClass) String 

func (c NameSplitClass) String() string

type NameSplitFloors 

type NameSplitFloors struct {
	// Calls is the minimum total calls (all three classes) per site.
	Calls [nameSplitSiteCount]int

	// Split is the minimum SPLIT population (splitBare + SPLIT-QUALIFIED) per
	// site — the calls that actually entered a splitting arm, as opposed to the
	// segmented calls that decided without one.
	//
	// It is a separate floor from Calls because at legQOVSegmentsOf the two
	// diverge completely: 9 calls, 0 of them splits. A healthy Calls total there
	// says the SEGMENTED arm is being reached and says nothing whatever about
	// the arms this census's hard zero is a zero over.
	//
	// A ZERO ENTRY IS A DECLARATION, NOT AN ABSENT FLOOR, and it is checked as
	// one: a site declared 0 whose split population is now non-zero FAILS, so
	// the "watched, not proven" label cannot silently outlive the condition that
	// made it honest. Declaring 0 means "this site's split arms are measured
	// empty over this corpus, they are covered by a unit wiring pin instead, and
	// the day the corpus starts driving them somebody re-reads this line."
	Split [nameSplitSiteCount]int
}

NameSplitFloors is the minimum population each site must report, so that a site going DARK is a failure rather than a clean-looking zero.

type NameSplitSite 

type NameSplitSite int

NameSplitSite is one of the TWO LEG BAKERS' arms that can still recover a qualifier by slicing a rendered name. It is not an enumeration of every such site in Go — the dark siblings named in this file's header are outside this census's scope and outside its zeros. 

const (
	// NameSplitSiteLegQOVSegmentsOf is query.bakeDottedRefsToLegQOVWithRef's
	// segmentsOf: the root node consults the carrier's parse-tree triple when it
	// is Present, and every other node — and every root whose carrier states
	// nothing — falls back to the slice.
	//
	// This baker is where a misread is most consequential: unlike the flat baker
	// it has no exact-name precedence to resolve a quoted spelling first, so the
	// split is the FIRST thing it does.
	NameSplitSiteLegQOVSegmentsOf NameSplitSite = iota

	// NameSplitSiteFlatColumnBake is query.bakeFlatRefsAgainstColumns' dotted
	// arm, reached only after the exact-name first-match over the output columns
	// has already failed. Its segmented counterpart is bakeSegmentedColumnRef,
	// which is a different function rather than a branch here — so this site
	// reports segmented 0 by construction, and that zero is structural, not a
	// finding.
	NameSplitSiteFlatColumnBake
)

func (NameSplitSite) String 

func (s NameSplitSite) String() string

type OrderingComparisonCensus 

type OrderingComparisonCensus struct {
	// Total is every comparison the site made.
	Total int64

	// FieldPairs is the comparisons where BOTH operands are plain FieldValues —
	// the type class identity decides.
	FieldPairs int64

	// FieldPairsDecided is the FieldPairs where both operands stated an
	// identity, so SameOrderingColumn had a domain and an ordinal on each side.
	FieldPairsDecided int64

	// DeclineResidual is the FieldPairs where at least one operand stated NO
	// identity. Type dispatch declines these, so this is the count that must be
	// ZERO: a nonzero value is a producer minting an ordering key without the
	// layout its ordinal indexes, and the fix belongs there, not here.
	DeclineResidual int64

	// ResidualWeakerArmsAgreed is the DeclineResidual pairs the retired
	// availability dispatch would ALSO have called unequal — a decline that
	// costs nothing.
	ResidualWeakerArmsAgreed int64

	// ResidualMatchesLost is the DeclineResidual pairs the retired availability
	// dispatch would have called EQUAL. Each one is a merge type dispatch gives
	// up, so this is the count whose zero makes the conversion free.
	ResidualMatchesLost int64

	// NonFieldPairs is the comparisons outside the FieldValue class — the
	// *RecordTypeValue discriminators the intersection carries, arithmetic and
	// function ordering keys, the CardinalityValue wrapper.
	NonFieldPairs int64

	// NonFieldBridgeOnly is the NonFieldPairs the ordinal-free NAME bridge
	// decides EQUAL and structural equality does not. It exists to answer
	// whether the bridge arm is still load-bearing once the FieldValue class no
	// longer reaches it; zero means it is measured dead code.
	NonFieldBridgeOnly int64
}

OrderingComparisonCensus is one site's decision population.

func OrderingComparisonCensusOf 

func OrderingComparisonCensusOf(site values.OrderingComparisonSite) OrderingComparisonCensus

OrderingComparisonCensusOf returns a snapshot of one site's counts.

type OrderingComparisonSiteLabel 

type OrderingComparisonSiteLabel values.OrderingComparisonSite

OrderingComparisonSiteLabel prints a values.OrderingComparisonSite.

func (OrderingComparisonSiteLabel) String 

func (s OrderingComparisonSiteLabel) String() string

type QualifierRecoveryClassLabel 

type QualifierRecoveryClassLabel values.QualifierRecoveryClass

QualifierRecoveryClassLabel prints a values.QualifierRecoveryClass.

func (QualifierRecoveryClassLabel) String 

func (c QualifierRecoveryClassLabel) String() string

type QualifierRecoveryExpectations 

type QualifierRecoveryExpectations struct {
	// Floors is the per-site population this corpus must report, or nil under a
	// -test.run filter that makes the population meaningless.
	Floors *QualifierRecoveryFloors

	// AllowedDiverged is every DIVERGED witness this corpus's own test FIXTURES
	// deliberately drive, per site.
	//
	// A corpus of SQL cannot need this: every one of its splits comes from a
	// production producer, so any disagreement there is a defect and the zero is
	// a bare zero. A corpus that calls package-private recorders with hand-built
	// fixtures DOES need it — the fixtures that prove the DIVERGED bucket is
	// REACHABLE necessarily fill it, and without them the census's one asserted
	// zero would be a zero nothing had ever shown could be non-zero.
	//
	// The check is per-witness rather than a count tolerance, so a real
	// divergence at a new spelling cannot hide inside a budget. The residual is
	// stated rather than smoothed: a real divergence spelled EXACTLY like one of
	// these is absorbed, because the witness set dedups by spelling — which is
	// why the entries are listed individually with the fixture that drives each.
	AllowedDiverged map[values.QualifierRecoverySite]map[string]struct{}

	// RetiredSplit names the sites whose SPLITTING ARM IS GONE — not measured
	// empty over this corpus, but structurally unreachable — so the alarm at them
	// has INVERTED from collapse to REVIVAL: any split call is the arm coming
	// back, and it fails.
	//
	// This is deliberately NOT the Floors.Split zero declaration, which says
	// "measured empty here, covered by a unit pin instead". Two differences, and
	// both matter:
	//
	//   - A declaration is a statement about THIS CORPUS. A retirement is a
	//     statement about the TREE, so it holds over any population — including
	//     the empty one a -test.run filter leaves behind. Floors are dropped under
	//     a filter because a population floor describes the unfiltered suite; a
	//     retirement must not be, because skipping it is the one direction that
	//     fails open.
	//   - The failure text differs, and the text is the whole value of a stale
	//     guard: a declaration says "raise this floor", a retirement says "the arm
	//     you deleted is back".
	//
	// A site listed here is exempt from the Floors.Split zero-declaration check,
	// so the two guards report the same event once, with the right words.
	RetiredSplit [values.QualRecSiteCount]bool

	// RetiredCalls forbids every class, including CARRIED, at a deleted site.
	// Like RetiredSplit, this tree invariant survives filtered/empty corpora.
	RetiredCalls [values.QualRecSiteCount]bool
}

QualifierRecoveryExpectations is what one CORPUS expects of the census. Two harnesses drive this instrument and they expect different things, so the expectations are a parameter rather than a constant.

type QualifierRecoveryFloors 

type QualifierRecoveryFloors struct {
	// Calls is the minimum total calls (all six classes) per site.
	Calls [values.QualRecSiteCount]int

	// Split is the minimum SPLIT population per site — the calls that actually
	// entered a splitting arm (AGREED + DIVERGED + MANUFACTURED + LEAF-ONLY +
	// BARE), as opposed to CARRIED calls that decided without one.
	//
	// Separate from Calls because at a site whose carried channel does the work
	// the two diverge completely: a healthy Calls total says the CARRIED arm is
	// reached and says nothing whatever about the arms this census's zeros are
	// zeros over.
	//
	// A ZERO ENTRY IS A DECLARATION, NOT AN ABSENT FLOOR, and it is CHECKED IN
	// THE STALE DIRECTION: a site declared 0 whose split population is now
	// NON-zero FAILS. The "watched, not proven" label cannot silently outlive the
	// condition that made it honest. Declaring 0 means "this site's split arms
	// are measured empty over this corpus, they are covered by a unit wiring pin
	// instead, and the day the corpus starts driving them somebody re-reads this
	// line."
	Split [values.QualRecSiteCount]int
}

QualifierRecoveryFloors is the minimum population each site must report, so a site going DARK fails rather than reading as a clean zero.

type QualifierRecoverySiteLabel 

type QualifierRecoverySiteLabel values.QualifierRecoverySite

QualifierRecoverySiteLabel prints a values.QualifierRecoverySite.

func (QualifierRecoverySiteLabel) String 

func (s QualifierRecoverySiteLabel) String() string

type SeedWindowReadClassLabel 

type SeedWindowReadClassLabel values.SeedWindowReadClass

SeedWindowReadClassLabel prints a values.SeedWindowReadClass.

func (SeedWindowReadClassLabel) String 

func (c SeedWindowReadClassLabel) String() string

type SeedWindowReaderFloors 

type SeedWindowReaderFloors struct {
	// Reads is the per-site minimum, indexed by site. A zero entry means the site
	// is not floored, which is a statement about the corpus and not an omission.
	Reads [values.SeedWindowSiteCount]int

	// Retired marks a site whose expected population is ZERO. Its alarm points
	// the other way from a floor: any read means the retired traffic came back.
	// A retired site must not also be floored.
	Retired [values.SeedWindowSiteCount]bool

	// NestedHitMustBeZero asserts that NO read selects a NESTED window.
	//
	// IT IS A TRIPWIRE, NOT A DEFECT GATE, and the inversion is the whole point:
	// a non-zero here is GOOD NEWS that requires ACTION. RFC-200's nested reader
	// arm is correct, cross-agreement-pinned on both entries and unit-pinned on
	// both arms, and no corpus query reaches it — a nested SUB-window is only
	// selected by a reference to a leg buried INSIDE the merge. Gate (a)'s four
	// mutation directions are therefore not yet writable.
	//
	// Without this assertion, activation day changes nothing visible. Whoever
	// produces a query whose reference reaches a buried leg would see a green
	// suite, a printed NESTED-HIT that nobody diffs, and gate (a) left unwritten
	// BY DEFAULT rather than by decision. This is what turns that day into a red
	// test with the hand-over in its failure message.
	//
	// Typing the bare-QOV result values does not reach that day: they are
	// already typed — every declined leg carries a real RecordType — and the leg
	// walk refuses on values.IsPositionalMergeRC, which needs a
	// *RecordConstructorValue that no QuantifiedObjectValue is at any typing.
	// `bare` there means identity PASS-THROUGH, not untyped.
	//
	// What would actually trip this tripwire is the SHAPE conversion: giving the
	// declined leg an RC(_i: QOV(leg_i)) result value, so a reference can reach a
	// leg inside the merge. That is a different change with a different risk
	// surface, and it is booked separately.
	NestedHitMustBeZero bool
}

SeedWindowReaderFloors is the minimum read count each site must report over a whole suite run.

Floored per SITE rather than in total, because the sites do not substitute for one another: a total floor stays satisfied with individual readers dark. That is the whole reason this instrument exists — the predecessor's deletion took away the only thing that could tell a silenced reader from a quiet corpus.

A total floor would also stay satisfied by the loudest site (gatheredGroupSlot) alone, so per-site flooring is what keeps each reader visible.

type SeedWindowSiteLabel 

type SeedWindowSiteLabel values.SeedWindowSite

SeedWindowSiteLabel prints a values.SeedWindowSite.

func (SeedWindowSiteLabel) String 

func (s SeedWindowSiteLabel) String() string

type SelectResultMintCounters 

type SelectResultMintCounters struct {
	// Calls counts every mint, per site.
	Calls [values.SelectResultMintSiteCount]int
	// TypedQOV / UntypedQOV split the QOV-shaped mints by whether they carry a
	// real flowed type. UntypedQOV is the DIVERGENCE population — see the floors.
	TypedQOV   [values.SelectResultMintSiteCount]int
	UntypedQOV [values.SelectResultMintSiteCount]int
	// OtherRV counts a mint that is not a QOV at all.
	OtherRV [values.SelectResultMintSiteCount]int
	// Shapes records the distinct spellings per site, for the same reason the
	// sibling censuses keep witnesses: a bucket that moves without a spelling
	// change is a different event from one that gains a spelling.
	Shapes [values.SelectResultMintSiteCount]map[string]int
}

SelectResultMintCounters is the census's state.

func SelectResultMintCensus 

func SelectResultMintCensus() SelectResultMintCounters

SelectResultMintCensus reports the counters.

type SelectResultMintFloors 

type SelectResultMintFloors struct {
	Calls [values.SelectResultMintSiteCount]int
}

SelectResultMintFloors is the mint census's gate.

Calls is a FLOOR: a site going dark must be visible, because every zero recorded beside a dark site measures an absence of traffic rather than an absence of the shape. Zero means NOT FLOORED, which for a floor is the same assertion as a floor of zero.

THE UNTYPED-QOV FLOOR IS GONE, and its absence is the reconciliation. It floored a DIVERGENCE — an untyped QuantifiedObjectValue, which Java cannot build — so that the gap stayed counted while it stood, with the DROP as the failing direction because a shrinking count cannot be told from a darkening site. The gap is closed at the constructor: NewQuantifiedObjectValue requires an exact type, so an untyped QOV is unrepresentable and this site mints none. A floor pointing at an impossible population is unsatisfiable, and lowering it to zero would leave the retirement unwatched — so the direction INVERTS and the zero is asserted unconditionally in assertSelectResultMintCounters.

type SelectResultMintSiteLabel 

type SelectResultMintSiteLabel values.SelectResultMintSite

SelectResultMintSiteLabel prints a values.SelectResultMintSite.

func (SelectResultMintSiteLabel) String 

func (s SelectResultMintSiteLabel) String() string

type UnnestLegMintArmLabel 

type UnnestLegMintArmLabel values.UnnestLegMintArm

UnnestLegMintArmLabel prints a values.UnnestLegMintArm.

func (UnnestLegMintArmLabel) String 

func (a UnnestLegMintArmLabel) String() string

type UnnestLegMintSiteLabel 

type UnnestLegMintSiteLabel values.UnnestLegMintSite

UnnestLegMintSiteLabel prints a values.UnnestLegMintSite.

func (UnnestLegMintSiteLabel) String 

func (s UnnestLegMintSiteLabel) String() string

type UnresolvedResultTypeFloors 

type UnresolvedResultTypeFloors struct {
	MinReads int
	MinSites int
}

UnresolvedResultTypeFloors are the two populations this census refuses to let collapse silently.

There is deliberately NO floor on the unresolved count and no zero to defend: RFC-213 has not been implemented, so the unresolved reads are the DEFECT and their number is a measurement, not a contract. What is guarded is the reading.

  • MinReads guards VACUITY. With no classified reads at all, a later "unresolved is now 0" is indistinguishable from success, so every finding denominated against this census becomes unreadable.

  • MinSites guards a DEAD INSTRUMENT. MinReads alone cannot see it: one hot consumer clears any read floor by orders of magnitude while every other deciding site reports nothing, and the census then speaks for a population it stopped observing.

BOTH ARE COLLAPSE GUARDS — the alarm is downward, and that is a statement with a shelf life. If RFC-213 lands and a consumer stops reading result types because it no longer needs to, zero becomes that site's steady state and MinSites becomes unsatisfiable. Reconcile it with the new expected value then; do not relax it to whatever the run produced, and do not delete it, which would leave the retired consumer's return unwatched.

A nil *UnresolvedResultTypeFloors, and equally a floors value of all zeroes, is a NO-OP by construction — the shape a narrowed run needs, where a whole-corpus population claim has nothing it can honestly decide.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.