values

func AccessorNamePath ¶

func AccessorNamePath(v Value) ([]string, bool)

AccessorNamePath returns the ordered accessor NAME path (root QOV/alias EXCLUDED) of a plan-time column reference, from the two STRUCTURED representations only (RFC-187 §3.0):

(a) nested Child chain → walk Child, prepend each Field, stop at the root QOV
(b) baked Resolved     → Resolved.Accessors[].Field (Child is the root QOV, excluded)

ok=false — a conservative "cannot establish identity", callers MUST NOT match — when:

• any accessor is pure-ordinal (Field==""): a machinery-owned bake has no name to compare, so identity is asserted-unknown here rather than falling back to a silent name match;
• a LAZY Field carries a '.' (flat-dotted "form c"): the string is AMBIGUOUS — a real nested path (addr.city) and an alias-qualified leaf (T.city / leg.COL, composed by clustered_outer_scalar / cascades_translator) are indistinguishable as strings, so splitting on '.' would be the very string hack this kills AND could mis-root an alias as an accessor. We deliberately do NOT split (this also disposes of the quoted-"a.b"-identifier concern — no split, no hack). Such a value must not reach a match site; if one does, ok=false makes it a loud conservative miss, never a wrong bind.

Names are UPPER-cased to the resolver's normalization rule so identity is case-insensitive at every accessor.

This is the match-DOMAIN column identity: the candidate side is name-based by construction (columnNames []string, no ordinals), so identity can only be compared in the name domain. The ordinal identity (FieldPath.Equals) is a different, evaluation-domain concern; unifying them by ordinalizing the candidate is the RFC-187 §8 / RFC-173-endgame follow-up.

func AccessorNamePathKey ¶

func AccessorNamePathKey(v Value) (string, bool)

AccessorNamePathKey returns a canonical map key for a column reference's accessor path (the path segments joined with a NUL separator), or ok=false when the path cannot be established (AccessorNamePath !ok). It is the map-keyed form of column identity over plain FieldValue references: two such references produce the same key iff ColumnNamePathsEqual reports them equal, so a set keyed by this string distinguishes a nested addr.city from a same-leaf-named top-level city. (It does NOT cover the CardinalityValue wrapper ColumnNamePathsEqual also handles — a CardinalityValue yields ok=false here; the key-form callers, S7/S9 grouping keys, never pass one.)

func AccessorNamePathMatchesNames ¶

func AccessorNamePathMatchesNames(v Value, candidate []string) bool

AccessorNamePathMatchesNames reports whether v's accessor name path equals the given candidate name path (already UPPER-cased accessor names, root→leaf). It is the value↔declared-path form used by the sites whose candidate side is a string path (aggregate group/agg columns, ordered index/PK sort columns) rather than a Value. A single-element candidate (a top-level column) therefore cannot match a nested query path — the fix for those sites (RFC-187 §3.2/§3.3).

THE ToUpper ON THE CANDIDATE IS LOAD-BEARING AND MUST NOT BE DELETED ALONE. It looks like one more site of RFC-237's fold class, and the candidate side genuinely does arrive canonical now. But AccessorNamePath (above) still folds the VALUE side, deliberately: five tests pin case-insensitive accessor identity as a match-domain rule (`lazyFlat("city")` equals `lazyFlat("CITY")`, `bakedFused("ADDR","City")` equals `bakedFused("addr","city")`). Fold one side and not the other and a verbatim candidate can never meet an upper-folded path — measured: an aggregate index over quoted columns silently stopped matching. The two folds are one decision. Change them together or not at all, and see RFC-237 §9 for what would settle whether to remove both.

func AliasMapSize ¶

func AliasMapSize(m AliasMap) int

AliasMapSize returns the number of pairs in m.

func ArithmeticOperandIsPrimitive ¶

func ArithmeticOperandIsPrimitive(tc TypeCode) bool

ArithmeticOperandIsPrimitive is Java's TypeCode.isPrimitive() as ArithmeticValue.encapsulate checks each operand before it looks up a lane (ArithmeticValue.java:215-220): UNKNOWN, NULL, BOOLEAN, BYTES, DOUBLE, FLOAT, INT, LONG, STRING, VECTOR and VERSION are primitive; ENUM, RECORD, UUID, ARRAY, RELATION, NONE and ANY are not (Type.java:774-791). It differs from TypeCode.IsPrimitive, which calls UUID primitive and UNKNOWN and NULL not. Go has no VECTOR code (a vector column types as BYTES here, primitive as Java's VECTOR is); DATE and TIMESTAMP, Go-only codes, are primitive (they have no lane either way).

func AssertOrdinalJoinSeed ¶

func AssertOrdinalJoinSeed(rc *RecordConstructorValue)

AssertOrdinalJoinSeed is the LOUD ordinal-join seed-shape validator: the translator calls it on every ordinal join RC it builds, where the pristine shape IS guaranteed by construction — every field a BAKED FieldValue over a leg QuantifiedObjectValue flowing a *RecordType, consecutive full-coverage leg runs with baked ordinals 0..width-1 ascending. Any violation panics: at the SEED a malformed ordinal RC is unconditionally a planner bug (strictness lives at seed-time, where legitimate result-value rewrites — wrapper merges, folded projections, partial coverage — cannot yet have happened; the executor's cursor-side ordinalJoinSpans probe DECLINES those shapes instead of panicking).

Lives in values (not executor) because the translator is the caller of record — a seed must never be built without this assert.

func BuildStructMessage ¶

func BuildStructMessage(
	md protoreflect.MessageDescriptor,
	fields map[string]any,
	convert func(fd protoreflect.FieldDescriptor, v any) (protoreflect.Value, error),
) (protoreflect.Value, error)

BuildStructMessage builds the nested message a STRUCT value stores, from the evaluated record constructor's field map. It is the structural half of Java's RecordConstructorValue.eval (RecordConstructorValue.java:113-139): walk the TARGET descriptor's fields, set each field present in the map, leave a NULL field ABSENT (:135's null branch — absence is what makes a nullable struct field read back as NULL), and reject a NULL at a non-nullable field.

The per-field VALUE conversion is the caller's, passed in: the plan-time writer (INSERT … VALUES) and the executor writer (UPDATE, INSERT … SELECT) have their own scalar lanes, already documented as siblings, and this exists so the STRUCTURE is not implemented twice alongside them.

func CanBridgeOrderingFieldValues ¶

func CanBridgeOrderingFieldValues(left, right Value) bool

CanBridgeOrderingFieldValues reports whether two non-structurally-equal ordering Values may safely be reconciled by their ordinal-free column name.

The bridge is deliberately narrow. SQL requested orderings are often plan-time-baked (COL#ordinal), while candidate orderings are rebuilt as lazy flat fields (COL); those two representations need to meet. Two baked fields never meet through this helper: different ordinals are different reads, even when their display names match. Childful/nested paths are also excluded because a leaf name does not identify their source slot.

Callers must test structural equality first. This helper handles only the representation bridge, including the harmless case-only difference between two lazy flat field names.

func CanBridgeOrderingValueRoots ¶

func CanBridgeOrderingValueRoots(left, right Value) bool

CanBridgeOrderingValueRoots reconciles the two safe representation seams an ordering request crosses on its way to a scan candidate:

• a lazy flat field and the same baked flat field;
• a field rooted at its owning SELECT quantifier and the same source-local candidate field.

The second bridge normally requires exactly one QOV-rooted side and compares the complete accessor name path. There is one deliberately narrower rooted exception: a values-owned tagged-current root may bridge to one ordinary named root. That is the physical-provider -> logical-request phase boundary; two named roots remain ambiguous (self-join hazard), and two independently minted current roots name different owner phases. A shared current handle is accepted only for an otherwise structurally identical value.

When both values carry baked paths, their ordinal paths must also agree; this prevents a QOV-rooted NAME#1 from collapsing with source-local NAME#2. A baked value may still bridge to a lazy value with the same complete name path. Callers must scope a request to its owning quantifier before using this bridge.

func CanonicalTimestampText ¶

func CanonicalTimestampText(t time.Time) string

CanonicalTimestampText is the TIMESTAMP text of an instant: UTC, to the second.

func CastEvaluated ¶

func CastEvaluated(v any, source, target Type) (any, error)

CastEvaluated applies CAST to a value whose declared SQL source type is known. A float64 carrier alone cannot distinguish FLOAT from DOUBLE. This shares the scalar/array conversion used by CastValue without constructing a child Value.

func CastPairDefined ¶

func CastPairDefined(from, to TypeCode) bool

CastPairDefined reports whether an explicit CAST from `from` to `to` has a defined operator (Java CastValue's construction-time gate — "No cast defined from X to Y" otherwise). Identity always casts; NULL casts to anything.

func CastTypesDefined ¶

func CastTypesDefined(from, to Type) bool

CastTypesDefined supplements the operator table with structural type checks. VECTOR has no conversion operator: only an identical shape can flow through unchanged. ARRAY casts must admit their element conversion recursively.

func CensusQOVShape ¶

func CensusQOVShape(rv Value) (isQOV, typed bool, label string)

CensusQOVShape classifies a minted select result for the select-result-mint census, which cannot see the unexported QOV it inspects.

func CheckPromotionsTrie ¶

func CheckPromotionsTrie(target, current Type) error

CheckPromotionsTrie is the admission half of Java's PromoteValue.computePromotionsTrie (PromoteValue.java:355-443): whether a value of type current can be stored in a slot of type target, walking records field by field (by position) and arrays element-wise. It answers only the verdict; carrying out the promotion is the caller's converter.

• ANY takes anything.
• A primitive (Java's TypeCode.isPrimitive: NULL, BOOLEAN, BYTES, DOUBLE, FLOAT, INT, LONG, STRING, VERSION, and Go's DATE and TIMESTAMP) of the slot's code needs nothing; into an array or a record it is refused (isPromotionNeeded's check); otherwise it needs a promotion the promotion map holds (IsPromotable).
• NONE (the untyped `[]`) needs NONE_TO_ARRAY.
• An enum takes only an enum equal to it but for nullability (Type.Enum compares its values, not its name); a UUID a UUID.
• Records need as many fields, each admitted; arrays their elements.

Where the two codes differ past the primitive arm (an enum into a string, an array into a scalar) Java fails a bare Verify.verify, an internal error ("XX000 null"); that is a refusal Java did not design, and this answers it with the designed one, INCOMPATIBLE_TYPE.

An UNKNOWN current type (Go's unresolved placeholder, which Java never plans with) is not a verdict: it is admitted here and left to the converter.

func CheckRangeBounds ¶

func CheckRangeBounds(position, end, step int64) error

CheckRangeBounds is Java's RangeValue.Cursor.checkValidRange.

func ClaimableOrderingPrefix ¶

func ClaimableOrderingPrefix(layout Type, names []string) int

ClaimableOrderingPrefix returns the leading name-resolved ordering prefix. Typed keys can use ClaimableTypedKeyPrefix or TypeTerminatesOrderingClaim directly.

func ClaimableTypedKeyPrefix ¶

func ClaimableTypedKeyPrefix(keys []Value) int

ClaimableTypedKeyPrefix is ClaimableOrderingPrefix for keys that carry their OWN declared type and have no flowed layout to resolve against — grouping keys, which the translator mints already typed.

A nil key is skipped rather than treated as terminating: an unidentifiable key is the same "burden of proof sits on the float side" trade TypeTerminatesOrderingClaim documents.

Two DIFFERENT questions are answered by this one count, and it is worth naming both because only the first is about ordering:

• Does the producer's advertised ORDER hold? Only for the leading prefix, so the claim is truncated there.
• Is the input CLUSTERED by the full grouping key? A streaming aggregation compares each row against the PREVIOUS group only, which is sound exactly when rows equal under the grouping identity are ADJACENT. A float coordinate breaks that too, and more sharply: the grouping identity is java.lang.Double.equals, which makes every NaN payload one value, while the tuple encoding scatters those payloads into two blocks at OPPOSITE ENDS of the key space. So the same group opens, closes and reopens, and the aggregation emits it twice. A consumer asking that question needs the count to reach len(keys) — a prefix is not enough, because clustering is a property of the whole key.

func CollectCorrelatedToOfValue ¶

func CollectCorrelatedToOfValue(v Value, out map[CorrelationIdentifier]struct{}) map[CorrelationIdentifier]struct{}

CollectCorrelatedToOfValue unions v's correlations into out, allocating out when nil. Callers folding several Value trees can share one result set.

func ColumnCanExtendOrderingClaim ¶

func ColumnCanExtendOrderingClaim(layout Type, name string) bool

ColumnCanExtendOrderingClaim resolves name against layout and reports whether that column may extend an ordering claim.

Returns true when the column cannot be shown to be a FLOAT/DOUBLE — see TypeTerminatesOrderingClaim for why the burden of proof sits on that side.

An AMBIGUOUS name (a layout declaring it twice, which is constructible because NewRecordType's duplicate check is case-SENSITIVE while column resolution is case-INSENSITIVE) terminates the claim if ANY matching field is a float. Addressability of an ambiguous key is a SEPARATE contract, already enforced downstream by the unique-match rule in bakeOrderingColumnIn — this predicate deliberately does not duplicate it, and answers only the question it owns: could this coordinate be a float?

func ColumnCouldBeFloat ¶

func ColumnCouldBeFloat(layout Type, name string) bool

ColumnCouldBeFloat resolves name against layout and reports whether that coordinate COULD hold a float — the question a signed-zero widening decision needs, and deliberately NOT the negation of ColumnCanExtendOrderingClaim.

The two differ exactly where the layout cannot answer, and the difference is the whole reason this exists. ColumnCanExtendOrderingClaim is permissive on an unresolvable layout (nil, not a *RecordType, no fields, name absent) because its own use is "may this coordinate extend a claim?", where permissive means GRANT and the burden of proof sits on the float side.

Inverted into a float test that answer flips meaning: "not a float" becomes "no signed zero", which becomes "this equality PINS", which is assume-SOUND — the unsound direction. A burden-of-proof direction does not survive an inversion, and reading one predicate backwards to answer the other silently turned a conservative default into an optimistic one.

That state is not hypothetical. plans.NewRecordQueryIndexPlan defaults a nil flowedType to UnknownType, and AggregateIndexMatchCandidate passes UnknownType explicitly; UnknownType is a *PrimitiveType, so it takes the not-a-record arm and every coordinate on such a plan reads as non-float. MEASURED live: a reachability probe in that arm fired under the planner suite.

So this asks positively and fails CLOSED — an unresolvable coordinate could be a float, so a zero-capable equality on it does not pin and the claim is refused. The cost is a sort that may not have been needed; the alternative cost is a wrong row order.

func ColumnNamePathsEqual ¶

func ColumnNamePathsEqual(a, b Value) bool

ColumnNamePathsEqual reports whether two plan-time column references denote the same accessor path (RFC-187 §3.0). It is the single match-domain column-identity notion; every value↔value match site routes through it.

Returns false — a conservative reject (the caller leaves the predicate a residual filter / does not elide the sort → correct rows, correct order via the slower path) — when either side's AccessorNamePath is !ok, or the paths differ at ANY position: every intermediate accessor is compared, not just the leaf, not leaf+root — which is what distinguishes a nested path from a same-leaf-named top-level column.

CardinalityValue is a transparent wrapper: CARDINALITY(x) matches CARDINALITY(y) iff x and y denote the same column. (DistanceRowNumber's metric-class discrimination is handled at its call site, which then compares the partition/argument column paths through this function.)

func ColumnNameValue ¶

func ColumnNameValue(v Value) string

ColumnNameValue renders v exactly like ExplainValue but WITHOUT the baked `#<ordinal>` accessor discriminators — the NAME-derivation rendering. Every place that derives an OUTPUT COLUMN NAME from a Value (aggregate result columns, group-key output columns, sort-key field refs, projection column defs) must use this form, never ExplainValue: a reference's column NAME must not change when the reference is bound to its ordinal at plan time, or the naming lockstep between the layers that render the name from DIFFERENT instances of the same reference (one baked, one lazy) silently breaks. ExplainValue keeps the ordinal discriminators for EXPLAIN/debug output, where collapsing two different reads is itself a bug.

func CompareExactInts ¶

func CompareExactInts(a, b any) (int, bool)

CompareExactInts compares two values EXACTLY when both are admitted integer forms — int/int8/int16/int32/int64 plus the uint/uint64 half the tuple layer uses for positive values above math.MaxInt64. ok=false when either side is not an integer. The order is by true numeric value — the order the FDB tuple integer encoding gives an indexed column — computed on (negative, magnitude) form so no pair round-trips through float64 (promotion ties adjacent values above 2^53 and at the 2^63 boundary).

func CompareFloat64 ¶

func CompareFloat64(a, b float64) int

CompareFloat64 is a total order over float64 faithful to Java's java.lang.Double.compare and Double.doubleToLongBits. Java Record Layer ordered comparisons use that order, and its boxed equality uses Double.equals, so both distinguish the zero signs and canonicalize NaNs. Go predicate comparison intentionally prechecks native IEEE equality in predicates.cmpAny: it makes -0 equal +0 while retaining this total order for non-equal values and NaNs. Sort, merge, and dedup consumers call this helper directly and therefore retain the Java/FDB-compatible zero-sign order.

Two edge values differ from Go's native float comparison:

• NaN sorts GREATER than every non-NaN value, and NaN compares equal to NaN (native `<`/`>` are both false, and `==` is false).
• Negative zero sorts strictly BEFORE positive zero: -0.0 < 0.0 (native `==` treats them as equal).

This matches FDB tuple order for ordinary values and the two zero signs, but deliberately not for arbitrary raw NaN encodings. FDB preserves NaN sign and payload, placing negative and positive NaNs in separate physical regions; this logical comparator canonicalizes them. Planner ordering/SARG proofs must therefore reject an unbounded or range-bound FLOAT/DOUBLE coordinate unless a separate normalization or compensation proof is available.

func CompareOrdered ¶

func CompareOrdered(a, b any) (int, error)

CompareOrdered is a total order over the concrete scalar/binary Go types the query engine's row and IN-list values take (the int/uint/float variants, bool, string, []byte, [16]byte UUID, and nil). It is the single Java-faithful natural order this codebase uses wherever two runtime values must be ranked against each other outside of an indexed comparison: in-memory sort, merge-cursor ordering keys, and a SORTED IN-join's literal list (cascades.sortInJoinValues).

Two edge cases differ from Go's native comparison operators, matching java.lang.Double.compare exactly (see CompareFloat64): NaN sorts greater than every non-NaN value and compares equal to NaN, and -0.0 sorts strictly before +0.0. Every other typed arm matches FDB's own tuple encoding order, so an in-memory ordering agrees with what an indexed scan of the same column would produce.

nil sorts before every other value (a nil pair compares equal). A pair with no shared typed arm returns a loud error rather than silently picking a wrong order — the planner's type checking is expected to exclude cross-type comparisons before this is ever called on production data, so this arm is a defensive backstop, not a designed code path.

func ContainsAggregate ¶

func ContainsAggregate(v Value) bool

ContainsAggregate reports whether v has any AggregateValue in its subtree. Common gate for rules that only apply to scalar expressions — aggregates need the accumulator path, not per-row Evaluate.

func ContainsBakedOrdinal ¶

func ContainsBakedOrdinal(v Value) bool

ContainsBakedOrdinal reports whether any FieldValue in v's subtree carries a MACHINERY-OWNED (FrontierPinned) baked-ordinal marker — the structural "is this an ordinal-join value tree" probe the join machinery keys on (SelectMergeRule target loop, the executor's ordinal-join construction). Deliberately blind to UNPINNED baked nodes (source-relative resolver bakes): those carry no join-frontier contract and must not trip join-seed machinery.

func DedupFieldNames ¶

func DedupFieldNames(names []string) []string

DedupFieldNames is THE rule that keeps a name-addressed record type name-addressable when a projection repeats an output name: a later occurrence takes a numeric suffix (`A`, `A_2`, `A_3`). It is a property of the TYPE, never of the SQL: Java has no such suffix — Type.Record keeps repeated field names and every read is bound by ordinal — so nothing user-visible may carry it. The result-set label of `SELECT a, a FROM T` is [A A].

Exported so that every layout that must equal a projection's runtime row (the ordinal seed's leg type, derived from the logical projection) applies the same rule instead of restating the names verbatim: a leg type that said [G G] over a row the projection emits as [G G_2] is a different ordinal domain, and the baked positional read of the second slot then declined and fell back to a by-name read that answered the FIRST G.

func DependsOnStatementClock ¶

func DependsOnStatementClock(v Value) bool

func DerivedStorageName ¶

func DerivedStorageName(name string) string

DerivedStorageName is the protobuf spelling Java gives a name that states none (Field.of, EnumValue.from: ProtoUtils.toProtoBufCompliantName).

func DescribeType ¶

func DescribeType(typ Type) string

DescribeType renders a Type as a compact, comparable shape for a diagnostic: `RECORD(LID:LONG,VAL:LONG?)`, `ARRAY<INT>`, `LONG?`. A trailing `?` marks nullable. It is the public twin of the rendering the exact-type conflicts use, for callers outside this package that hold a Type rather than a handle.

func DisplayColumnName ¶

func DisplayColumnName(v Value, alias string) string

DisplayColumnName is the USER-VISIBLE label for a projected column: the alias when the column carries one, else its own name with the QUALIFIER removed — Java's Identifier.withoutQualifier, applied by the top-level clearQualifier (Identifier.java:101-106). `SELECT n.sk` is column SK.

This is deliberately NOT OutputColumnName. The qualifier belongs in the internal slot key, where it is what keeps two legs' same-named columns apart; it does not belong in anything a user names the column by. Wherever a projection's name CROSSES into SQL — a result-set label, a CTE's column list — the display form is the authority, and disagreeing about that is how one recursive CTE came to declare its column N.SK while every reference to it resolved SK.

The leaf is taken from the RESOLVED ACCESSORS, never by splitting the rendered name: a column may legally be named with a dot in it (`"A.ID"`), and a last-dot split would tear that name in half.

func EffectiveListField ¶

func EffectiveListField(fd protoreflect.FieldDescriptor) (list protoreflect.FieldDescriptor, wrapped, ok bool)

EffectiveListField resolves a column field to its effective REPEATED field:

• a flat repeated field returns itself (wrapped=false);
• a singular message field whose message is the wrapper returns the inner `values` field (wrapped=true);
• anything else returns (nil, false, false).

func EqualsWithoutChildren ¶

func EqualsWithoutChildren(a, b Value) bool

EqualsWithoutChildren checks whether two Values are the same type with the same non-child attributes, WITHOUT recursing into children. This is the Go equivalent of Java's Value.equalsWithoutChildren().

For leaf values (no children) this is equivalent to ValuesStructurallyEqual. For composite values it checks the type and any type-specific attributes (operator, field names, etc.) but does NOT compare children.

Returns true if a and b have the same concrete type and the same non-child attributes (e.g. same ArithmeticOp, same field names in RecordConstructorValue, same CastValue target type, etc.).

func EvaluateConstant ¶

func EvaluateConstant(v Value) (out any, ok bool)

EvaluateConstant attempts to fold v to a concrete literal at plan time. Returns (literal, true) when v is constant (per IsConstantValue); (nil, false) otherwise. Safe on nil (returns (nil, false)). Useful for rules that want to pre-compute a constant sub-expression without writing an `if isConstant { eval and wrap }` dance every time.

A data-dependent runtime error from Evaluate (arithmetic overflow, division by zero, invalid cast, type mismatch) is reported as "not foldable" — (nil, false). This is the plan-time decline-to-fold path: the typed runtime-error family now returns via the error channel, so the error is swallowed here (leave the node) rather than surfacing a query error from the planner.

Genuinely programmer-invariant panics (e.g. an AggregateValue buried inside a constant tree that IsConstantValue should have excluded) are planner bugs and now surface rather than being silently swallowed — the residual recover that masked them has been collapsed.

func ExactTypesEqual ¶

func ExactTypesEqual(left, right ExactTypeHandle) bool

ExactTypesEqual reports whether two exact handles denote the same type. It is FlowedTypesEqual for callers that hold bare handles rather than quantifiers — an expression's snapshotted target or result type, say — and it exists for the same reason: `left.Type().Equals(right.Type())` builds two whole graphs to answer a boolean, and both operands were already immutable identities.

Read its contract off exactTypesEqual, not off pointer identity: two handles can denote one type and still be two objects, because interning keys on the record and enum name that Type.Equals ignores.

Two absent handles are NOT equal, matching FlowedTypesEqual. `Type()` on a nil handle yields a nil Type and the comparison it replaces panicked there, so there is no prior answer to preserve — and "neither side can state a type" is not evidence that they state the same one.

func ExplainPlanValues ¶

func ExplainPlanValues(vs []Value) []string

ExplainPlanValues renders one plan node's retained Value program in a stable local correlation namespace. Unique correlations are allocation identities, so their process-global numeric suffixes must not leak into plan text: doing so makes two structurally identical plans explain differently solely because another query happened to allocate aliases first.

A program with one unique correlation and no bare QOV omits that root, which preserves the familiar `ID#0` spelling for a projection over one input. With multiple unique roots (or a bare scalar QOV) the roots are numbered q$0, q$1, ... by first structural occurrence. Named correlations — including a quoted user alias whose text looks like q$7 — are never rewritten.

func ExplainValue ¶

func ExplainValue(v Value) string

ExplainValue renders a Value as a readable expression string. Free function rather than a Value-interface method so existing third-party Value impls (once the port grows) don't have to track another method. Walks children recursively for composite values like ArithmeticValue / CastValue.

Output style matches SQL-ish expression rendering:

ConstantValue     → the literal as %v
FieldValue        → the field name
ArithmeticValue   → (left OP right)
BooleanValue      → TRUE / FALSE / NULL
CastValue         → CAST(child AS TypeX)
NullValue         → NULL

func ExplainValueOverInput ¶

func ExplainValueOverInput(v Value, input CorrelationIdentifier) string

ExplainValueOverInput renders v like ExplainValue with the input correlation spelled as the current row, as Java prints a plan's own input as `_`. The input alias is minted per planning run; printing it would make the plan text depend on allocation order, and so would any other unique root v reads (an outer row the plan is correlated to), which is numbered as ExplainPlanValues numbers its roots.

func ExplicitStorageName ¶

func ExplicitStorageName(name, storage string) string

ExplicitStorageName is storage when name does not already imply it.

func ExtractFromIndexEntry ¶

func ExtractFromIndexEntry(v Value, baseAlias CorrelationIdentifier, source TupleSource, ordinalPath []int) (FieldValue, Value, bool)

ExtractFromIndexEntry is Java's Value.extractFromIndexEntryMaybe: the ExtractFromIndexKeyValueRuleSet computed over an index entry column's Value v. It answers the base field the column holds and the reader that recovers that field from the entry bound under the current correlation. A column that is no field of the base (an arithmetic function, a field of an exploded element) has no extraction, nor does one whose type no entry leaf can carry.

func FieldNameForProtoField ¶

func FieldNameForProtoField(field protoreflect.FieldDescriptor) string

FieldNameForProtoField is THE single authority for the NAME a stored column's slot carries in a values.Type: the user identifier, VERBATIM.

A protobuf field name is the STORAGE spelling — `$`, `.` and `__` are escaped (`a$b` is stored as `A__1B`). Java keeps the two apart on the type itself: `Type.Record.fromDescriptorPreservingName` records `ProtoUtils.toUserIdentifier(descriptor.getName())` as the name and the raw descriptor name as the storage name, and `Type.Record.Field` does the same per column — the wire keeps the escaped spelling, the SQL surface sees the user's.

Go's SQL catalog already un-escapes (rlcatalog), so a Value-tier type built straight off the descriptor states a DIFFERENT name for the same column than the reference that reads it. Under RFC-232 those two are compared as exact types, so the disagreement is not cosmetic: it is a hard "type disagrees with declared binding" at evaluation, and every query over a table with an escaped identifier fails.

It does not FOLD, for the same reason Java does not: the only normalization in the language is at the parse boundary (SemanticAnalyzer.normalizeString — quoted keeps its case, unquoted folds UPPER), and every catalog comparison after it is exact. A fold here was invisible for a DDL-created schema, whose descriptor names are already the normalized spelling, and wrong for everything else — it named a column something no reference could spell, and it made the index-matching bridge miss SILENTLY (RFC-237 §2.1).

func FlowedRowShapeEquals ¶

func FlowedRowShapeEquals(value QuantifiedObjectValue, typ Type) bool

FlowedRowShapeEquals is FlowedRowShapesAgree against an ordinary Type — a declared row an executor binding carries, say — where there is no second handle to compare with.

It routes the quantifier's side through the SHARED thawed graph, so the walk runs against a graph allocated once per interned type rather than once per call. That is the whole saving available on this shape; see FlowedTypeEquals.

func FlowedRowShapesAgree ¶

func FlowedRowShapesAgree(left, right QuantifiedObjectValue) bool

FlowedRowShapesAgree reports whether two quantified object values denote the SAME BOUND ROW, answered from the exact handles. It is QuantifiedRowShapesAgree's question — see that function for why the top-level nullable bit is excluded from a row's shape and why one alias legitimately carries two QOVs differing only there — with neither graph built.

Same relation, not an approximation of it: exactRowShapesAgree is the handle-side twin, and every ordered pair of a type corpus is swept in exact_type_equality_differential_test.go to keep the two answering alike.

func FlowedTypeEquals ¶

func FlowedTypeEquals(value QuantifiedObjectValue, typ Type) bool

FlowedTypeEquals reports whether value flows exactly typ.

The other side is an ordinary Type here — a layout's carrier, a plan's declared row, a query result — so there is no second handle to compare against and the graph has to be walked. What this avoids is BUILDING one: SharedFlowedType hands back the thawed graph cached on the interned handle, so the walk runs against a value that is allocated once per interned type for the life of the process instead of once per call.

Argument order does not affect the answer. Every Type implementation's Equals type-asserts the operand to its own concrete type before comparing anything, so all six are symmetric, and a call site that had the ordinary type on the left reads the same through here. TestTypeEqualsIsSymmetricOverTheCorpus pins that rather than leaving it as a claim, because it is the one property that lets these call sites be rewritten without checking each one's orientation.

The result is READ-ONLY on the value's side and this function never lets it escape — that is the whole reason the shared graph is safe here while FlowedType stays the default everywhere the graph is stored or handed onward.

func FlowedTypesEqual ¶

func FlowedTypesEqual(left, right QuantifiedObjectValue) bool

FlowedTypesEqual reports whether two quantified object values flow the same row type. It is what `left.FlowedType().Equals(right.FlowedType())` asks, answered from the immutable exact handles, building NEITHER graph.

The spelling it replaces allocates two complete Type graphs to produce one bool, and thaw was the single largest allocator in the planner because of it. The handles are already there: a quantified object value IS an exact handle plus a correlation, and comparing two handles is a pointer test, then a hash, then one bytes.Equal over a canonical encoding.

It is `exactTypesEqual` and NOT handle pointer identity, and the difference is the whole reason this function exists rather than being written inline at each call site. Identity is strictly STRICTER than Type.Equals: the intern table keys on the record and enum NAME, while RecordType.Equals and EnumType.Equals deliberately ignore it to match Java. Two Equals-equal rows can therefore hold two handles, and an identity test would call them different — a false negative, in the direction that changes plans. The canonical encoding exact_type.go builds excludes the name precisely because Equals does, which is what makes this substitution equal by construction rather than by an argument about interning. exact_type_equality_differential_test.go sweeps every ordered pair of a type corpus to keep it that way, and fails on 22 pairs if anyone "simplifies" this to `==`.

A value that cannot state a flowed row answers FALSE rather than panicking, as the expression it replaces did when the LEFT side was unusable — and answered false, inconsistently, when the right side was. Every caller here is asking whether two rows are the same, and "cannot tell" and "not the same" lead to the same fail-safe branch: rebuild, refuse the rewrite, miss the lookup.

func GetCorrelatedToOfValue ¶

func GetCorrelatedToOfValue(v Value) map[CorrelationIdentifier]struct{}

GetCorrelatedToOfValue walks v + its descendants and returns the union of every correlation-bearing leaf Value's alias. Handles QuantifiedObjectValue, QuantifiedRecordValue, ScalarSubqueryValue, ObjectValue, and UnmatchedAggregateValue. ExistsValue is a transparent composite — its child QuantifiedObjectValue is reached via the Children() descent.

Returns nil for nil input. Returns a non-nil empty map for trees with no correlations.

Ports Java's Value.getCorrelatedTo().

func GetCorrelatedToWithoutChildrenOfValue ¶

func GetCorrelatedToWithoutChildrenOfValue(
	v Value,
) map[CorrelationIdentifier]struct{}

GetCorrelatedToWithoutChildrenOfValue returns only the correlations carried by v itself, excluding correlations contributed by descendant Values.

This is the Go counterpart of Java Value.getCorrelatedToWithoutChildren(). Keep the switch in lockstep with the correlation-bearing leaf cases in GetCorrelatedToOfValue. Composite wrappers such as FieldValue and ExistsValue deliberately contribute nothing here even though their full subtree correlation set is non-empty.

func GetOption ¶

func GetOption[T any](o CallSiteOptions, option CallSiteOption[T]) (T, bool, error)

GetOption is Options.get: the option's value coerced to its type.

func IsAny ¶

func IsAny(t Type) bool

IsAny reports whether t is the universal supertype. Mirrors Java's `Type.isAny()`.

func IsArithmeticFunction ¶

func IsArithmeticFunction(function string) bool

IsArithmeticFunction reports whether function (any case) is one of ArithmeticValue's logical operators, the functions Java builds through encapsulate and so the ones a lane decides.

func IsArray ¶

func IsArray(t Type) bool

IsArray reports whether t is an ARRAY (concrete or erased). Mirrors Java's `Type.isArray()`.

func IsCanonicalCurrentOnlyOrdinalLayout ¶

func IsCanonicalCurrentOnlyOrdinalLayout(layout OrdinalLayout) (bool, error)

IsCanonicalCurrentOnlyOrdinalLayout reports whether layout carries only its tagged-current object and therefore needs no retained-source bindings or per-row window presence. Record tile shape may be flat or nested: both are canonical carrier-relative addressing once source windows are absent.

A valid windowed layout returns (false, nil). Foreign, nil, and typed-nil views fail loudly before any interface method is invoked, matching the other layout purpose APIs.

func IsCascadesSafeScalarFunction ¶

func IsCascadesSafeScalarFunction(name string) bool

IsCascadesSafeScalarFunction reports whether the named scalar function is admitted to the Cascades SQL pipeline.

func IsConstantExpression ¶

func IsConstantExpression(v Value) bool

IsConstantExpression also admits statement-pool references: row-independent, but their value is known only at execution.

func IsConstantOver ¶

func IsConstantOver(v Value, localAliases map[CorrelationIdentifier]struct{}) bool

IsConstantOver reports whether v is constant over an operator binding localAliases: it reads neither those aliases nor the operator's input row, and holds no aggregate or queried value (Java's MatchConstantValueRule, whose AggregateValue includes the record constructor).

func IsConstantValue ¶

func IsConstantValue(v Value) bool

IsConstantValue reports whether v's Evaluate is row-context- independent — its value is known at plan time. True for ConstantValue, NullValue, BooleanValue, and any composite whose children are all constants (`1 + 2`, `CAST(5 AS STRING)`). False for FieldValue / QuantifiedObjectValue / AggregateValue and any composite containing them.

Used by code that only acts on fully-foldable operands (e.g. range enclosure's compile-time comparand).

func IsEnum ¶

func IsEnum(t Type) bool

IsEnum reports whether t is an ENUM. Mirrors Java's `Type.isEnum()`.

func IsFunctionallyDependentOn ¶

func IsFunctionallyDependentOn(v Value, otherValue Value) bool

IsFunctionallyDependentOn reports whether v is functionally dependent on otherValue — meaning v's output is fully determined by otherValue's output. Ports Java's Value.isFunctionallyDependentOn.

Returns true if all correlation-bearing leaves in v reference the same correlation as otherValue (when otherValue is a QOV). Returns false if any leaf references a different scope, or if otherValue is not a QOV.

func IsIndexOnly ¶

func IsIndexOnly(v Value) bool

IsIndexOnly is a helper that any Value can call to check whether v requires an index scan to produce its result.

func IsMixedSeedElementType ¶

func IsMixedSeedElementType(t Type) bool

IsMixedSeedElementType decides whether a bare QuantifiedObjectValue carrying this type is the MIXED seed's whole-object SCALAR element — Java's `isPrimitive()` branch, the element the seed cannot ofOrdinal-bake and so gives its own synthesized 1-field window.

It is one predicate rather than two identical ones because the planner's window derivation (OrdinalSeedLegWindows) and the executor's span derivation (unnestMixedSeedSpans / ordinalJoinSpans) must agree on it BIT FOR BIT: they walk independently, and a disagreement about which field is the element is a wrong-offset read of every field after it. Two copies of a rule agree until one of them is edited.

The test is "not a RECORD", and it is a PROXY for the question actually being asked — is this field one slot, or is it a leg occupying width-many? — so it is worth being exact about why the proxy holds, because it did not always.

It holds because a LEG's quantifier object now states its row. While the flowed object value was minted untyped, an untyped leg was not a record either, so a leg flowing a whole multi-column row was admitted as a one-column element and a 2-slot record constructor of bare untyped quantifier objects was accepted outright, at widths nobody had checked. Typing the flowed value closed that: a leg reads as a RecordType and is rejected here, measured as flowed 848 of 848 leg derivations over the real-FDB corpus with underivable at zero. The bakeability census asserts that zero, so the fact this proxy rests on is enforced rather than assumed.

What it does NOT do is demand a STATED type, and that is deliberate rather than an oversight. An unnest element over an array of STRUCTS is a genuine whole-object element — one slot, the whole struct, exactly the case this arm exists for — and its type is UNKNOWN because Go does not infer array element types that far. Requiring a stated type declines it and `SELECT "X" FROM TS, TS."ITEMS" AS "X"` stops resolving. So an unstated type stays admitted, and the leg side is what carries the discrimination.

func IsNonEvaluable ¶

func IsNonEvaluable(v Value) bool

IsNonEvaluable is a helper that any Value can call to check whether v is plan-time-only. Avoids type-assertion boilerplate in callers.

func IsNone ¶

func IsNone(t Type) bool

IsNone reports whether t is the NONE type (untyped empty array). Mirrors Java's `Type.isNone()`.

func IsNull ¶

func IsNull(t Type) bool

IsNull reports whether t is the NULL literal's type (TypeCodeNull). Mirrors Java's `Type.isNull()`.

func IsNullStrictValue ¶

func IsNullStrictValue(v Value) bool

IsNullStrictValue reports whether v is one of the classes Java's CollapseNullStrictValueOverNullValueRule.VALUE_CLASSES lists: ArithmeticValue, CastValue, FieldValue, NotValue, PromoteValue and SubscriptValue. KEEP IN SYNC with that list.

func IsOrdinalFieldName ¶

func IsOrdinalFieldName(name string) bool

IsOrdinalFieldName reports whether name is a planner-internal ordinal-addressed field key (`_0`, `_1`, …) — OrdinalFieldName's inverse, digits-only (OrdinalFieldName never emits signs, so `_-1`/`_+0` are NOT ordinal keys). User columns cannot take this form (a parsed identifier's leading `_` is legal, but the positional-merge and Explode-ordinality producers are the only writers of these keys in a merged row).

func IsOrdinalJoinRV ¶

func IsOrdinalJoinRV(v Value) bool

IsOrdinalJoinRV reports whether v is an ordinal-model JOIN-SELECT result value: a raw (non-anchored) RC whose every field is a FrontierPinned baked reference over a quantifier — the flat N-leg seed and its TranslationMap- translated upper forms (fused multi-accessor paths included) — spanning at least two distinct root quantifiers. This is the ordinal counterpart of the AnchoredJoin marker for the interning gate: the shapes whose quantifiers have no external identity consumer, where alias-IDENTITY dedup re-explodes the join re-enumeration's shared sub-products per bipartition. A lazy field anywhere (CTE column renames, computed projections) declines — those selects keep the alias-identity dedup that Go's column derivation requires.

func IsPositionalMergeRC ¶

func IsPositionalMergeRC(v Value) bool

IsPositionalMergeRC is the VALUE-level half of the structural merge-select recognition (no imperative marker — the exact shape PartitionSelectRule.java:284-291 builds and nothing else can): an RC whose every field is auto-generated-named ("_i", in position order — Java Type.java:2922 isAutoGenerated) and whose value is a BARE QOV of a distinct quantifier. The SELECT-level half (the QOVs are the select's own owned ForEach quantifiers, covering them) lives at the interning gate; the executor checks the QOVs against its two legs. Unconstructible from SQL: the generator names all columns, so CTE column-rename selects never match. Lives beside ContainsBakedOrdinal — the two value-shape probes ordinal join construction triggers on.

func IsPromotable ¶

func IsPromotable(from, to Type) bool

IsPromotable reports whether `from` can be implicitly promoted to `to` without an explicit CAST. Returns true when:

• from.Code() == to.Code() (identity, same type code).
• The (from.Code, to.Code) pair is in the promotionMap.

Mirrors Java's `PromoteValue.isPromotable`. Nullability is NOT part of the promotion check — a NOT NULL value can always be stored in a nullable slot of the same code, and a nullable value being stored in a NOT NULL slot is rejected at the caller (NOT NULL constraint), not by promotion.

Arrays / records / enums / vectors with structural inner types need element-by-element checks done by the caller (Java's isPromotionNeeded recurses for these); IsPromotable only handles the top-level code pair.

func IsPromotionNeeded ¶

func IsPromotionNeeded(from, to Type) (needed, ok bool)

IsPromotionNeeded is PromoteValue.isPromotionNeeded: whether a value of type from must be promoted to be used as type to. Nullability is not part of it; a record needs promotion when a field's type, name or position differs. ok is false where Java raises INCOMPATIBLE_TYPE (records of different arity, a primitive against a structure).

func IsRecord ¶

func IsRecord(t Type) bool

IsRecord reports whether t is a RECORD. Mirrors Java's `Type.isRecord()`.

func IsRelation ¶

func IsRelation(t Type) bool

IsRelation reports whether t is a RELATION. Mirrors Java's `Type.isRelation()`.

func IsRowVersionPseudoField ¶

func IsRowVersionPseudoField(name string, t Type) bool

IsRowVersionPseudoField reports whether a resolved field is THE row-version pseudo-field: name and type must both match, mirroring the two-sided check Java applies before emitting VersionKeyExpression.VERSION for it (MaterializedViewIndexGenerator.toFieldKeyExpression, MaterializedViewIndexGenerator.java:821-823: type equality with PseudoField.ROW_VERSION.getType() AND field-name equality).

func IsUnresolved ¶

func IsUnresolved(t Type) bool

IsUnresolved reports whether t is one of the placeholder types (UNKNOWN / NULL / NONE / ANY) — i.e. the type isn't a concrete shape that can carry data on its own. Mirrors Java's `Type.isUnresolved()`.

func IsUuid ¶

func IsUuid(t Type) bool

IsUuid reports whether t is a UUID. Mirrors Java's `Type.isUuid()`.

func IsWrappedArrayDescriptor ¶

func IsWrappedArrayDescriptor(md protoreflect.MessageDescriptor) bool

IsWrappedArrayDescriptor reports whether md is the NullableArrayWrapper shape: exactly one field, named "values", repeated. Mirrors Java's NullableArrayUtils.isWrappedArrayDescriptor.

func JavaDoubleToString ¶

func JavaDoubleToString(f float64) string

JavaDoubleToString is Java's Double.toString(double).

func LayoutProvides ¶

func LayoutProvides(layout OrdinalLayout, source QuantifiedObjectValue) (bool, error)

LayoutProvides reports whether layout contains the exact source window. A missing window is a typed optional physical miss, not an untyped false.

func LayoutSatisfies ¶

func LayoutSatisfies(layout OrdinalLayout, required RequiredBindings) (bool, error)

LayoutSatisfies applies one immutable binding manifest to a candidate provided layout. Missing windows are a normal physical incompatibility; malformed/extra/colliding sources remain errors.

func LayoutWindowNullSupplying ¶

func LayoutWindowNullSupplying(layout OrdinalLayout, source QuantifiedObjectValue) (bool, error)

LayoutWindowNullSupplying reports whether one exact local source window is null-supplying. This is physical layout authority: record nullability alone cannot distinguish a retained nullable value from a source which was absent because an outer-join edge did not match.

func LayoutWindowWithin ¶

func LayoutWindowWithin(layout OrdinalLayout, source, parent QuantifiedObjectValue) (bool, error)

LayoutWindowWithin reports whether every carrier path of source's window lies inside parent's window: a source buried in a retained box leg, which a join may publish without its child binding that source on its own.

func LegAwareRootOrdinal ¶

func LegAwareRootOrdinal(vt FieldValue, srcOrd int, rc *RecordConstructorValue, fallbackOrd int) int

LegAwareRootOrdinal resolves the seed-RC slot for a SourceRelativeBaked reference collapsed over a flat leg-concatenation seed (a merged box/join whose RC concatenates each leg's columns, every field a baked FieldValue over its OWN leg's QOV — NewRawRecordConstructorValue, values.go). The reference's baked ordinal is relative to its OWN leg, so applying it directly to the seed picks the wrong slot; and with columns colliding across legs (dept.id AND emp.id) a bare-name match picks the first occurrence — again the wrong leg, the raw-RC duplicate-name conflation. Disambiguate by the reference's OWN leg (vt.Child's correlation): pick the seed field whose value is a FieldValue over that SAME correlation, matched by leg-relative ORDINAL.

Two name arms used to sit under that, and both are gone (RFC-197 item 3):

• a within-leg name TIEBREAK, for a seed field carrying no baked ordinal. "A single source has unique column names" is the argument it rested on, and it is an argument for the ordinal, not against it: where the names are unique the ordinal answers identically, and where they are not the name is wrong. A seed field with no ordinal states nothing, so it is skipped.
• a cross-leg name FALLBACK, for a seed whose leg field is a bare QOV rather than a per-column FieldValue (a lateral unnest). It resolved a UNIQUE name and poisoned a duplicate — the guard being the admission that the key was wrong, since two bare-QOV legs exposing the same column reach here indistinguishable. Every such seed now poisons.

Poison (-1) is the fail-closed answer for both: the caller leaves the reference UN-COLLAPSED rather than collapsing it onto a slot chosen by a display name, which is loud on a positional row and never a wrong slot. It is the same ambiguity-poison discipline bakeMergeComparisonKeys and rich_ordering apply.

Deliberately NOT falling back to fallbackOrd: that is the reference's RAW leg-relative ordinal, and applying it to the box's concatenated RC picks the FIRST leg's slot — the wrong-leg bug this function exists to prevent (it once turned `e.id IS NULL` into `d.id IS NULL` and made a LEFT-join anti-join return zero rows). fallbackOrd is used only where a leg-relative rebase was never needed.

func LikeOperation ¶

func LikeOperation(operand any, pattern any) (any, error)

LikeOperation is LikeOperatorValue.likeOperation (LikeOperatorValue.java:93-105): NULL for a NULL operand, a NULL pattern record or an absent pattern; otherwise the match.

func MatchLike ¶

func MatchLike(text, pattern string, escape *string) (bool, error)

MatchLike is LikeOperatorValue.matchLike (LikeOperatorValue.java:145-241), ported over the same UTF-16 code units Java's String holds: `%` matches any run, `_` one unit or one surrogate pair, an escaped character that unit literally; nothing treats a line terminator specially. A nil escape is no escape. The escape and every escape sequence met are re-checked as Java re-checks them.

func MessageFromRowValues ¶

func MessageFromRowValues(md protoreflect.MessageDescriptor, vals []any) (protoreflect.Message, error)

MessageFromRowValues builds a message of md from row values by field position, leaving the field of a nil value unset: a RecordConstructorValue's message over values already evaluated.

func NestedResolvedPath ¶

func NestedResolvedPath(v Value) (string, bool)

NestedResolvedPath returns the upper-cased dotted PATH a FUSED NESTED field reference reads, and reports whether v is one.

THE DEFINITION OF "NESTED" IS THE MULTI-ACCESSOR RESOLVED PATH, and it is one function because the predicate is the whole subtlety. The SQL resolver FUSES `n.sk` into ONE FieldValue with Resolved=[N,SK] — Java does exactly the same fuse (SemanticAnalyzer.lookupNestedField, SemanticAnalyzer.java:598 `FieldValue.ofFieldsAndFuseIfPossible`) and then names the result by the REQUESTED IDENTIFIER `n.sk` rather than by the fused value (SemanticAnalyzer.java:599).

`Field` cannot substitute, and the reason SURVIVED the mint fix that made it the LEAF name. It used to answer "what struct does this read out of", so `n.sk` and `n.co` shared it; it now answers "which member", so `t1.n.sk` and a flat `sk` share it instead. Either way it is one segment of a path and the question here needs all of them. Every output-naming authority must take the path. Reading `Field` there spells two different columns alike, and a name-keyed reader then serves one of them where the other was asked for.

THE PATH IS QUALIFIED WHEN THE REFERENCE HAS A CHILD, and that is a decision, not a leak. With ≥2 FROM sources the resolver emits the reference through its quantifier (`resolveScopedColumn`'s correlated arm), so the FieldValue carries `Child = QOV(T1)` and this returns `T1.N.SK`; with one source it returns `N.SK`. MEASURED end-to-end: `SELECT n.sk, n.co FROM t1, t2` explains as `Project([T1.N#1.SK#0, T1.N#1.CO#1], ...)` against `Project([N#1.SK#0, ...])` for the single-source form.

The qualifier is KEPT because dropping it would be the same conflation one level up: over `FROM t1, t2` where both declare an `n`, `T1.N.SK` and `T2.N.SK` are different columns and a bare `N.SK` collapses them in exactly the name-keyed maps this predicate exists to protect. It is also what the two neighbouring authority already does for a childful reference — `sortKeyFieldRef` renders `LEG.COL` (cascades_translator.go) — so qualifying here makes the nested arm agree with it rather than inventing another rule. The remaining asymmetry is ProjectionColumnName's own non-nested arm, which returns a bare `Field`; that arm is deliberately untouched, because changing it moves emitted names for every flat qualified projection and is a separate change.

Java agrees, and structurally: the fused nested reference is named by the REQUESTED IDENTIFIER (`SemanticAnalyzer.java:599`), an `Identifier` whose `fullyQualifiedName()` retains its qualifiers, and the top-level projection then strips them for the user-visible label (`Identifier.withoutQualifier`, Identifier.java:101). Go does the same: the display label for both forms is the bare leaf `SK` — measured, so the qualifier is an INTERNAL slot key and never reaches the user.

A path step can never contain the `#` that explainValueOrdinals escapes: a struct member name must be a valid protobuf identifier and DDL refuses anything else ("field name \"a#1\": a#1 it not a valid protobuf identifier", measured). That is now belt AND braces rather than the only argument — the escape no longer fires on an ordinal-free rendering at all. See the escape's own note in explainValueOrdinals.

func NewWrappedArrayMessage ¶

func NewWrappedArrayMessage(fd protoreflect.FieldDescriptor) (msg *dynamicpb.Message, values protoreflect.List)

NewWrappedArrayMessage builds an empty wrapper message instance for the given wrapper field (a field whose message is the wrapper shape). The caller appends elements to the returned list and stores the message value on the field.

func OrderingFieldPair ¶

func OrderingFieldPair(a, b Value) bool

OrderingFieldPair reports whether both ordering values are plain FieldValue column reads. It is the TYPE test that dispatches the two ordering comparators: a pair inside this class is decided by SameOrderingColumn and by nothing else, with no fallthrough.

Finality is what the type test buys: an UNKNOWN-domain or rootless FieldValue cannot fall through to a weaker comparison and bridge two distinct exact columns (StatesOrderingColumn carries that witness).

A CardinalityValue wrapping a field is deliberately OUTSIDE the class. It is not a column of any row layout, so it has no column identity to state and is matched as a whole Value instead.

func OrdinalCarrierMatchState ¶

func OrdinalCarrierMatchState(
	layout OrdinalLayout,
	presence WindowMatchPresence,
) (matched bool, known bool, err error)

OrdinalCarrierMatchState reads the optional whole-current-object state after exact-recognizing both inputs. Absence of a carrier marker is not an error: ordinary rows predate no match decision and are therefore treated as present by their executor owner. A hostile presence implementation is never invoked through its public interface.

func OrdinalFieldName ¶

func OrdinalFieldName(ordinal int) string

OrdinalFieldName is the display name for an anonymous record field addressed by ordinal position. Java's planner names anonymous explode-with-ordinality fields `_0` (element) and `_1` (ordinal) — see the `q1._0` / `q1._1` access in the EXPLAIN output. The positional row type carries these names for the WITH-ORDINALITY element/ordinal slots; an ordinal-addressed FieldValue (Java's `FieldValue.ofOrdinalNumber`) reads the slot by ordinal.

func OrdinalSeedLegLayout ¶

func OrdinalSeedLegLayout(rc *RecordConstructorValue) (map[CorrelationIdentifier]OrdinalSeedLegWindow, *RecordType, []OrdinalSeedLegWindow)

OrdinalSeedLegLayout is OrdinalSeedLegWindowsAcceptingNested plus the TOP-LEVEL RUN LIST: the windows that TILE the merged row, in offset order.

THE MAP CANNOT SERVE THIS, and that is why the walk returns it rather than a caller deriving it. finalizeSeedWindows' rightmost-leaf case REPLACES a box run's own entry with a narrower sub-window — deliberately, because the box IS its rightmost leaf under the sourceBinding convention and an alias-qualified read must window the leaf rather than look the name up across the whole concat. So after finalization "the windows that tile the row" is simply not recoverable from the map: one of the tiles has been overwritten by something narrower, and nothing distinguishes that from a seed that always had a narrow leg there.

It is the planner twin of what the executor already returns — ordinalJoinSpansOf's `spans []legSpan`, in offset order — which is the shape this list is modelled on rather than invented against.

Callers that only need the addressable map keep the two-value entries; this answers the different question "how many legs TILE this row, and what shape is each".

The run list preserves tiling that finalization's narrower map entries lose; it has no production consumer.

func OrdinalWindowMatchState ¶

func OrdinalWindowMatchState(
	layout OrdinalLayout,
	presence WindowMatchPresence,
	source QuantifiedObjectValue,
) (bool, error)

OrdinalWindowMatchState returns the exact per-row match state of one null-supplying source window. Both layout and presence are values-owned and exact-recognized; missing state is a malformed physical row, never an invitation to infer absence from all-NULL field values.

func OutputColumnName ¶

func OutputColumnName(v Value, alias string) string

OutputColumnName is the projection OUTPUT-name authority: the name that keys the emitted positional row's slot for a projected column, and therefore the name any downstream re-reader must use on the ordinal frontier — the upper-cased ALIAS when the column carries one, else the ProjectionColumnName rendering. It lives here so every site derives the name from ONE rule instead of a hand-synchronized copy — two copies of this rule have disagreed before (the executor wrote alias-preferring slot names while the recursive-CTE leg wrap re-read by ProjectionColumnName alone — a loud OrdinalResolutionError on valid SQL, no fallback by design). Both sites delegate here.

func ParseJavaUUID ¶

func ParseJavaUUID(s string) ([16]byte, bool)

ParseJavaUUID parses s exactly as java.util.UUID.fromString does: five dash-separated hex components, each read by Long.parseLong(radix 16) (so a sign, Unicode digits and short or over-wide components are accepted) and masked to its field width; no braces, URN prefix or undashed form.

func ParseTemporalText ¶

func ParseTemporalText(s string) (time.Time, error)

ParseTemporalText reads the text of a DATE or TIMESTAMP value, in UTC. The year domain keeps every canonical text parseable and in instant order: an offset can carry a year-9999 text into year 10000 in UTC.

func ProjectionColumnName ¶

func ProjectionColumnName(v Value) string

ProjectionColumnName is the projection output-column NAMING CONTRACT: the name a projected Value's result is keyed under, alias-absent, in the emitted positional row's type. A NESTED FieldValue projects under its resolved PATH ("N.SK"); any other FieldValue under its (possibly dotted) Field; any other Value under its upper-cased ORDINAL-FREE rendering (a computed expression like `n + 1` is keyed "(N + 1)"). Shared here so the planner/translator side can READ a projection's output by the exact key the executor WRITES — reading by any other rendering (e.g. the logical layer's un-parenthesized "N + 1") is a loud OrdinalResolutionError on valid SQL.

ORDINAL-FREE IS THE WHOLE POINT OF THE THIRD ARM, and it was ExplainValue until the corpus showed what that costs. An ordinal is a PLAN-TIME BINDING of a reference; a column's name is not, so a name carrying one changes when the same reference is baked — the lockstep ColumnNameValue exists to hold. The composite arm was the one route that could mint such a name (the other two return schema text), and it did: `SELECT id + 1` inside a CTE keyed its output `(C1.ID#0 + 1)`, which the enclosing projection then re-read as a FIELD whose text contains a `#`, so the explain escape doubled it and the slot key read `(C1.ID##0 + 1)`. One line of the corpus carried it (cte.yaml#25) — the escape mechanism is in explainValueOrdinals' fieldValue arm, which now doubles only when it is rendering ordinals to disambiguate from.

The nested arm is NOT a special case bolted on: it is the same rule the sort side already applies (sortKeyExtraColumnName) and the same rule Java applies to every resolved reference. `Field` carries ONE segment — the struct root when this was written, the leaf now — so without the path `SELECT n.sk, n.co` emitted two slots named `N` (measured, visible to the user as duplicate column labels over correct data) and `SELECT t1.n.sk, sk` would emit two named `SK`. The path is what separates them.

func ProjectionOutputIdentityKey ¶

func ProjectionOutputIdentityKey(v Value, alias string) string

ProjectionOutputIdentityKey returns an opaque, boundary-safe discriminator for the parts of a projection's executor-visible output name that semantic Value identity does not already preserve.

A non-empty alias is the entire output-name authority, normalized exactly as OutputColumnName normalizes it. Without an alias, the Value's tree shape, operators, literals, and correlation structure already participate in semantic identity; the missing discriminator is every FieldValue's rendered display path. In particular, baked FieldValues compare by ordinal path alone, while ProjectionColumnName and ExplainValue still render their Field text (and a multi-accessor Explain renders every resolvedAccessor.Field). Walking all nested FieldValues therefore distinguishes both A#0 from B#0 and arithmetic expressions containing those reads.

CorrelationIdentifier spellings are deliberately excluded. They are alpha-renamable planner binders, not SQL output aliases: SemanticEqualsUnderAliasMap equates their Values through an AliasMap and SemanticHashCode is alias-invariant so hash-first memo lookup can find those equal expressions. A stable SQL-visible projection name is carried by an explicit projection alias or by FieldValue display paths, both folded here.

func ProjectionOutputSchemaIdentityOverrides ¶

func ProjectionOutputSchemaIdentityOverrides(
	projections []Value,
	aliases []string,
	outputNames []string,
) ([]string, error)

ProjectionOutputSchemaIdentityOverrides returns only the externally frozen portion of a projection schema: each slot whose authoritative output name differs from the name the Value program and aliases naturally derive. The resulting sparse vector is suitable for memo identity.

This distinction is load-bearing. Internal Value names can contain alpha-renamable correlation identifiers (a scalar-subquery QOV is the canonical example), so folding every derived result field name into a hash breaks alias invariance. Conversely, an SQL boundary may deliberately freeze a different positional key (`S.ID` over a Value naturally named `ID`); that difference is executable schema and must keep the projections apart. nil is returned when no frozen name adds information beyond the natural schema.

func ProjectionSlotName ¶

func ProjectionSlotName(v Value, alias string) string

ProjectionSlotName is the name a projection's frozen output schema gives a slot BEFORE deduplication — the alias when the item carries one, the display name (qualifier stripped) for a column reference, and OutputColumnName's rendering for everything else. It is the rule exactProjectionForLogicalProject freezes with, and the rule a consumer must re-derive the natural schema by when it asks whether a frozen name is that schema's own deduplication suffix or an external rename. Two copies of the rule have disagreed before: the natural schema was once re-derived by OutputColumnName alone, which names a nested reference by its dotted path (`N.SK`) where the freeze names it `SK`, so `SELECT sk, n.sk` read the frozen `SK_2` as a rename and published the suffix as a label.

func ProtoFieldReadsValue ¶

func ProtoFieldReadsValue(m protoreflect.Message, fd protoreflect.FieldDescriptor) bool

ProtoFieldReadsValue is the presence rule by which a query reads a record's field: a repeated field is always read (as its list), a singular one only when it is set, and is otherwise NULL. Set is protobuf-java's hasField for either kind of presence, so an implicit-presence (proto3) field at its default is NULL.

An unset proto2 field that declares a default is NULL too, though Java's field reader, MessageHelpers.getFieldOnMessage (MessageHelpers.java:124-142), reads the default: a query never hands it the stored record. QueryResult.fromQueriedRecord (QueryResult.java:256-281) first copies the record into a message of the plan's type (MessageHelpers.deepCopyMessage, which copies getAllFields, the set fields), whose descriptor, generated from the type, declares no default. Measured through SQL on both engines (conformance "WS-J an unset field with a declared default reads as the target reads it"): SELECT *, a projection and a predicate all read NULL.

func ProtoFieldToRowValue ¶

func ProtoFieldToRowValue(fd protoreflect.FieldDescriptor, v protoreflect.Value) any

ProtoFieldToRowValue converts one proto FIELD value to the engine's row-value domain — the SINGLE conversion both the executor's record→row materialization and this package's struct descent use (exported so the two cannot drift; the executor's protoFieldToGo delegates here). Repeated fields become []any (a downstream Explode's collection); a proto map stays its raw Go value; scalars and UUID/message leaves go through protoScalarToRowValue.

func ProtoRecordDescriptorCompatible ¶

func ProtoRecordDescriptorCompatible(descriptor protoreflect.MessageDescriptor, declared ExactTypeHandle) bool

ProtoRecordDescriptorCompatible admits a protobuf-backed output carrier against an exact logical declaration. Storage is addressed by ordinal, not logical field names. Logical scalar/record nullability is not descriptor presence; nullable arrays may also read an already-unwrapped repeated field. Duplicate declared names are not representable as a protobuf record type; machinery-owned duplicate columns retain their ordinal-row representation.

func ProtoScalarKindToRowValue ¶

func ProtoScalarKindToRowValue(kind protoreflect.Kind, v protoreflect.Value) any

ProtoScalarKindToRowValue is the kind-keyed scalar conversion (no UUID/ message handling — that needs the descriptor, see protoScalarToRowValue). Exported as the single source of truth the executor's kind-based conversion calls directly, so the record→row and struct-descent conversions cannot drift on the scalar arms.

func PullUpValues ¶

func PullUpValues(toBePulledUp []Value, resultValue Value, alias CorrelationIdentifier) (map[Value]Value, error)

PullUpValues translates a list of values through a result value, returning a map from original value to pulled-up value. Values that cannot be pulled up are omitted from the map.

This is the batch form used by Ordering.PullUpThroughValue.

func QuantifiedRowShapesAgree ¶

func QuantifiedRowShapesAgree(left, right Type) bool

QuantifiedRowShapesAgree reports whether two exact QOV flowed types denote the SAME BOUND ROW. It is the one comparison every runtime QOV *lookup* uses, and it deliberately excludes the top-level nullable bit.

That bit is not part of a row's shape: on a quantifier it declares that the quantifier's row may be ABSENT, and absence is carried structurally by the binding itself — a nil row, or a positive explicit-absence proof — never by the row's type. Evaluating FieldValue(qov, i) against a present row is bit-identical whichever way the bit is set, and against an absent one both yield NULL, so the bit can decide nothing at a lookup.

One alias therefore legitimately carries two QOVs differing only there. That pairing is Java's, not a Go accident: an outer join's OUTPUT columns are pulled up through Quantifier.pullUpResultColumnsWithNullability(true), which mints QuantifiedObjectValue.of(alias, rowType.withNullability(true)), while the same alias's ON/WHERE predicates keep reading getFlowedObjectValue() — the leg's own, non-nullable row. Java binds both by alias alone; Go's exact channel keeps the strictly stronger check on everything that IS shape.

Field names, ordinals, arity, record names and every NESTED nullability still have to match exactly, so a foreign owner spelled with the same alias is still refused. Type DERIVATION sites (layout window construction, the null-supplying proofs, metadata nullability) must keep comparing with Equals: there the bit is the whole point.

func QuantifierFlowsAScalarRow ¶

func QuantifierFlowsAScalarRow(value Value) bool

QuantifierFlowsAScalarRow reports whether value is a quantified object value whose flowed row is NOT a record — the shape an UNNEST leg over a scalar array produces, where the quantifier's "row" is one bare value rather than a struct.

It exists because both callers were spelling the same three-part test inline (is it a QOV, can it state a row, is that row a non-record) and the middle part is only there to make the third safe. Naming the question keeps the guard from being read as redundant and dropped, which would turn "cannot state a row" into "flows a scalar row" — the wrong answer, and a silently wrong output LABEL rather than a crash.

func RangeAliasPairs ¶

func RangeAliasPairs(m AliasMap, yield func(AliasPair) bool) bool

RangeAliasPairs calls yield for each pair of m until it returns false, and reports whether every call returned true. The order is unspecified.

func ReadsConstantPool ¶

func ReadsConstantPool(v Value) bool

DependsOnStatementClock reports whether the value tree contains a CURRENT_TIMESTAMP-family function — one whose result is defined by the statement clock rather than by its (zero) arguments. The executor computes this ONCE per operator to decide whether a bare frontier row must be wrapped in a clock-bearing RowEvalContext: evaluating such a value against a bare OrdinalRow falls back to per-row time.Now() and drifts across the rows of one statement, which SQL forbids. ReadsConstantPool reports whether v dereferences a statement constant pool, which only a RowEvalContext with the statement binder can resolve.

func RecordNameForDescriptor ¶

func RecordNameForDescriptor(descriptor protoreflect.MessageDescriptor) string

RecordNameForDescriptor is FieldNameForProtoField's twin for the record's own name, un-escaped by the same rule.

func ResolveAssignmentColumn ¶

func ResolveAssignmentColumn(names []string, column string) (idx, hits int)

ResolveAssignmentColumn resolves one name of a DML statement's assigned field (a segment of an UPDATE's SET column: a qualifier, a column or a struct field) among the names at that level, to its position. names are user identifiers: a descriptor field's storage name decoded once (FieldNameForProtoField). The caller (the SET column's resolution) walks the segments level by level, as Java's SemanticAnalyzer resolves the identifier against the target Type.Record, and the FieldPath it builds carries the resolved ordinals RecordQueryUpdatePlan keys its transformation trie by, so nothing looks the name up again. Nothing here may decode a name a second time: the storage escaping is not injective under it (`a$b` is stored as a__1b, `a__1b` as a__01b, and decoding `a__1b` again gives `a$b`).

column is normalized (a quoted identifier keeps its case, an unquoted one is upper case). An exact match wins; otherwise one case-insensitive match does, the lookup extension DIVERGENCES.md declares ("Identifier resolution: Go over-resolves case"). hits is the number of columns the deciding pass matched: 1 resolved (idx is its position), 0 no such column, more than one ambiguous.

func RowValuesFromMessage ¶

func RowValuesFromMessage(msg protoreflect.Message) []any

RowValuesFromMessage is MessageFromRowValues' inverse: each field of msg in the row domain, nil where unset.

func SameColumnPath ¶

func SameColumnPath(a, b *fieldPath) bool

SameColumnPath reports whether two RESOLVED accessor paths denote the same column. It is the ORDINAL-PATH element of the identity triple asked BETWEEN two references, rather than resolved into a caller's stated layout the way IdentityIn is — the shape a matcher holding both operands needs. The CORRELATION element is not covered here; SameOrderingColumn compares it separately before consulting this path predicate.

Java's FieldPath.equals is element-wise ordinal equality with the per-step name excluded (FieldValue.java:411-420, over resolvedAccessor.equals at :676-685, which is getOrdinal()-only). Go needs two proofs on top, both for shapes Java cannot express:

• the DOMAIN, KNOWN on both sides and equal. Java's childValue is non-null and typed, so the layout an ordinal indexes is always derivable; Go mints childless bakes, and two ordinal-equal paths can address two different layouts. An ordinal conflation reads as authoritative, which is strictly worse than the name conflation it would replace.
• a NON-NEGATIVE ordinal at every step. Java asserts ordinal >= 0 at construction (FieldValue.java:651); Go mints Ordinal -1 name-only accessors at its unnest/gather/index-expansion seeds. Two of those are ordinal-equal BY CONSTRUCTION, so an ordinal comparison over them is vacuous and would bind two distinct nested fields as one.

Both declines are the fail-closed direction: a refused match costs a rewrite, an accepted one binds the wrong column.

func SameLeg ¶

func SameLeg(a, b CorrelationIdentifier) bool

SameLeg reports whether two identifiers name the same quantifier — the CORRELATION element of RFC-197's identity triple, compared in ONE place so every proof that asks "does this value read that leg?" gets the same answer.

The comparison is EXACT, matching Java, whose CorrelationIdentifier.equals is `Objects.equals(id, that.id)` (CorrelationIdentifier.java:132).

Exactness is not merely Java-fidelity here — it is load-bearing. Alias namespaces in this planner are deliberately case-DISJOINT: the semantic scope upper-folds every user correlation at its single registration chokepoint (semantic/scope.go), while UniqueCorrelationIdentifier mints the machine counter in LOWERCASE (`q$1`). scope.go states the consequence it is protecting: a quoted `"q$5"` cannot forge a planner-minted q$5. A case-folding comparison erases exactly that protection — it lets a user alias that upper-folds onto the minted namespace be accepted as the minted leg, and every caller of this helper is a proof about which row a value reads. A forged match there is a wrong-rows plan or a fabricated cardinality, not a lost optimization.

The same call was already made independently at the qualified-key rewrite in rule_implement_nested_loop_join.go, whose comment reads "a fold here would let a quoted user alias cross into the lowercase machine namespace". This helper now agrees with it rather than contradicting it.

Folding was tempting because the translator does not upper-case aliases consistently — some paths fold an alias at construction and others pass the spelling through verbatim — so an exact comparison can fail to recognize a leg that really is the right one. (This used to cite three specific translator lines; two of them had already drifted onto unrelated code, which is why the claim is stated structurally now. A line number is not a citation once the file moves under it.) That costs a DECLINE — every caller reads "cannot tell" as "do not apply the correction" — and it is the translator's inconsistency to fix at the source, not this helper's to mask. Masking it here would trade a recoverable missed optimization for an unrecoverable forged identity. An UNSTATED identifier (the Go zero value, empty name) names nothing, and two of them name nothing in common. Go's zero value has no Java analogue — Quantifier.getAlias() is @Nonnull and a CorrelationIdentifier is never constructed empty — so the only way to hold one here is a producer that forgot to state an identity. Answering "same leg" for that pair is how an unstated-identity leg binds a zero-value correlation and starts serving its slots: every caller reads true as "this correlation names this leg". Declining turns the omission into the miss it actually is.

func SameOrderingColumn ¶

func SameOrderingColumn(a, b Value) bool

SameOrderingColumn reports whether two ORDERING Values denote the same column by identity: the same ordinal path in the same STATED layout, read off the same exact root. Both sides must have stated an identity; a side that has not declines, and nothing here consults a display name.

It is the ordinal-domain counterpart of CanBridgeOrderingValueRoots' name comparison, and it exists because the obvious alternative is unsound: ValuesStructurallyEqual routes two baked FieldValues through FieldPath.Equals, which is ordinal-only and DOMAIN-BLIND (Java's resolvedAccessor.equals, FieldValue.java:675-689 — sound there because a Java FieldValue always has a non-null typed childValue, so the layout an ordinal indexes is never in question). RFC-232 now gives both candidate and request keys exact QOV roots. Requiring root equality keeps self-join columns apart and makes the comparator reflexive, symmetric, and transitive.

func ScalarFunctionNames ¶

func ScalarFunctionNames() []string

ScalarFunctionNames returns a fresh sorted snapshot of registered spellings. Aliases remain separate because each is an independently reachable SQL name.

func SemanticEqualsUnderAliasMap ¶

func SemanticEqualsUnderAliasMap(a, b Value, aliases AliasMap) bool

SemanticEqualsUnderAliasMap reports whether two Values are equal up to the quantifier-alias correspondence in `aliases` — the bool, alias-map-keyed counterpart of EqualsWithoutChildren+children, for memo interning and relational EqualsWithoutChildren (RFC-040 040.2). Correlation-bearing leaf Values compare their alias through the map (an unmapped alias maps to itself, so identical aliases compare equal under the empty map); every other Value compares structurally via EqualsWithoutChildren and recurses children under the same map.

This is consistent with SemanticHashCode: when this returns true, the two values have equal SemanticHashCode (both alias-invariant on the leaf aliases). Distinct from the cascades ValueEquivalence path, which carries QueryPlanConstraints for match-candidate compensation; this is the constraint-free bool primitive the expression/memo layer needs.

func SemanticHashCode ¶

func SemanticHashCode(v Value) uint64

SemanticHashCode returns an ALIAS-INVARIANT structural hash of a Value: the contract (Java Correlated.semanticHashCode) is

SemanticEqualsUnderAliasMap(a, b, m)  ⟹  SemanticHashCode(a) == SemanticHashCode(b)

for ANY alias map m — so the hash must NOT depend on specific quantifier-alias names. Correlation-bearing leaf Values (QuantifiedObjectValue, QuantifiedRecord, Object, ConstantObject, Exists, ScalarSubquery, UnmatchedAggregate, IndexEntryObject, JoinMerge) hash to a per-type tag with the alias EXCLUDED; value-bearing leaves (ConstantValue, BooleanValue, ParameterValue) fold their literal; structural Values fold a type tag + children.

Lives in the values package (RFC-040 040.1b relocation) so both expressions (for relational EqualsWithoutChildren/HashCodeWithoutChildren, 040.2) and cascades (memoEqual) can use it without an import cycle. Inert until those call sites switch to it.

func SemanticHashCodeIn ¶

func SemanticHashCodeIn(h io.Writer, v Value) uint64

SemanticHashCodeIn is SemanticHashCode in the mode of the enclosing hash h.

func SetCensusHooks ¶

func SetCensusHooks(leg *CensusHooks, ordering *OrderingHooks)

SetCensusHooks installs (or, with nil, removes) the two census slots.

func SetRelOpEvaluator ¶

func SetRelOpEvaluator(f func(comparison RelOpComparison, left, right any) (any, error))

SetRelOpEvaluator installs the comparison evaluation RelOpValues use.

func StatesOrderingColumn ¶

func StatesOrderingColumn(v Value) bool

StatesOrderingColumn reports whether ONE ordering value has stated a column identity SameOrderingColumn can read — a flat-or-nested resolved path in a known layout, off an exact quantifier root.

It is deliberately a ONE-VALUE predicate, and that shape is the whole point. The pairwise form it replaced ("do BOTH sides state an identity?") was used to DISPATCH: identity decided the pair when both stated one, and a pair where either side did not fell through to the domain-blind structural comparison. That dispatch is INTRANSITIVE inside the FieldValue class. Witness, all three values baked at ordinal path [0]:

A = [0] in layout D1          states an identity
B = [0] in layout D2          states an identity
U = [0], layout UNKNOWN       states none

Identity separates A from B (different layouts, EqualsWithoutChildren's FieldValue arm never looks at the layout). Availability dispatch sends both A~U and B~U to the structural arm, which compares ordinals only and says EQUAL. So U≡A, U≡B, A≢B — and a comparator that is not an equivalence relation makes every set it builds depend on INSERTION ORDER, which is a nondeterministic plan.

So dispatch is by TYPE — both operands *fieldValue means identity decides and the decision is FINAL — and this predicate exists only to CLASSIFY the population, never to choose an arm. A value that does not state an identity is UNADDRESSABLE: the comparator declines it, and the fix belongs at the producer that minted it without a layout.

func StringToEnumNumber ¶

func StringToEnumNumber(ed protoreflect.EnumDescriptor, name string) (int64, error)

StringToEnumNumber is Java's PromoteValue.stringToEnumValue over a stored enum descriptor (PromoteValue.java:151-161): the first declared value whose user identifier (ProtoUtils.toUserIdentifier of its name) equals name, else INVALID_ENUM_VALUE. It is what writes a string into an enum column, where Java's STRING_TO_ENUM promotion runs; no other type promotes to an enum.

func ToFloat64 ¶

func ToFloat64(v any) (f float64, isFloat, numeric bool)

ToFloat64 reports whether v is numeric (int-like or float) and returns its float64 promotion. isFloat distinguishes native-float inputs from integral ones promoted here — comparison-time promotion uses it to prefer the int path when both sides are integral.

func ToInt64 ¶

func ToInt64(v any) (int64, bool)

ToInt64 reports whether v is an integral type; returns the int64 promotion when so.

func TupleElementToRowValue ¶

func TupleElementToRowValue(v any) any

TupleElementToRowValue converts a decoded tuple element read off an index entry or primary key into the row domain base records are read into, so a column compares, sorts, dedups and joins alike whichever access path sourced it: a tuple UUID is [16]byte, a FLOAT (a 32-bit tuple float) is float64 as ProtoScalarKindToRowValue widens it, and a VERSION index's versionstamp is the record version's 12 raw bytes (FDBRecordVersion.toBytes). Java's tupleValueToRuntimeValue conversions (INT, BYTES, ENUM) are identities here.

func TypeTerminatesOrderingClaim ¶

func TypeTerminatesOrderingClaim(t Type) bool

TypeTerminatesOrderingClaim returns true for FLOAT/DOUBLE because tuple NaN ordering differs from logical ordering. It ignores scan bounds.

Unknown layouts retain sort elimination; soundness depends on SQL columns carrying types. Keep range-aware refinements here so planner and rowdiff use the same policy.

func ValidateOrdinalJoinSeedForLegs ¶

func ValidateOrdinalJoinSeedForLegs(rc *RecordConstructorValue, legs []QuantifiedObjectValue) error

ValidateOrdinalJoinSeedForLegs checks the complete declared input population, including zero-width legs which cannot be inferred from field runs. Each non-empty leg must contribute every direct, frontier-pinned ordinal exactly once, in declaration order. Empty legs contribute multiplicity, not fields.

func ValidateOrdinalLayoutAdmission ¶

func ValidateOrdinalLayoutAdmission(view OrdinalLayout) error

ValidateOrdinalLayoutAdmission exact-recognizes a layout without invoking methods on a hostile interface implementation.

func ValidateProjectionAliasSources ¶

func ValidateProjectionAliasSources(
	sources []ProjectionAliasSource,
	aliasMinted []bool,
	slots int,
) error

ValidateProjectionAliasSources checks a slot-parallel alias-source vector. A source can exist only for a machinery-minted alias, and absence must carry no hidden correlation. A short vector is valid and means uncaptured sources.

func ValidateRequiredBindingsAdmission ¶

func ValidateRequiredBindingsAdmission(view RequiredBindings) error

ValidateRequiredBindingsAdmission exact-recognizes a binding manifest without invoking methods on a hostile interface implementation.

func ValueSize ¶

func ValueSize(v Value) int

ValueSize returns the total node count in v (v + all descendants). Counterpart to PredicateSize for the Value tree. Rule authors use this to gate expensive rewrites that would otherwise explode tree size.

func ValuesStructurallyEqual ¶

func ValuesStructurallyEqual(a, b Value) bool

ValuesStructurallyEqual reports whether two Values are structurally equal: same concrete Go type, same metadata, and recursively equal children. Stronger than ExplainValue comparison which could theoretically collide on structurally different values that render the same string.

func WalkValue ¶

func WalkValue(v Value, visit func(Value) bool)

WalkValue applies visit to every node in v's subtree, pre-order. If visit returns false, descent into that node's children is skipped (siblings + ancestors continue). Rule authors use this for tree-wide searches — e.g. "does any sub-expression reference this correlation?" or "does this Value tree contain an aggregate?".

Safe on nil: returns immediately. Mirrors WalkPredicate over the Value side of the hierarchy.