executor

type AggregateTypeMismatchError ¶

type AggregateTypeMismatchError struct {
	Message string
}

AggregateTypeMismatchError is returned when MIN or MAX is applied to a non-numeric column. Java's fdb-relational rejects this with "VerifyException: unable to encapsulate aggregate operation due to type mismatch(es)" — the function registry only installs numeric MIN/MAX overloads.

func (e *AggregateTypeMismatchError) Error() string

type ColumnDef ¶

type ColumnDef struct {
	Name     string // output column name (positional slot / by-name lookup key)
	Label    string // display name (alias); empty means use Name
	TypeName string // JDBC type name: BIGINT, STRING, DOUBLE, etc.
	Nullable int    // api.ColumnNoNulls / ColumnNullable / ColumnNullableUnknown
}

ColumnDef describes one column in the result set.

type EvaluationContext ¶

type EvaluationContext struct {
	// contains filtered or unexported fields
}

EvaluationContext holds runtime bindings for plan execution: parameter values, correlation bindings (for correlated subqueries), scalar subquery results, and any mutable state that plan nodes share. Mirrors Java's EvaluationContext.

func EmptyEvaluationContext() *EvaluationContext

func (ec *EvaluationContext) BindParameter(ordinal int, name string) (any, bool)

func (ec *EvaluationContext) GetBinding(id values.CorrelationIdentifier) (any, bool)

func (ec *EvaluationContext) GetCorrelationBinding(id values.CorrelationIdentifier) (any, bool)

func (ec *EvaluationContext) GetOrCreateTempTable(id values.CorrelationIdentifier, st *recordlayer.ExecuteState) *TempTable

func (ec *EvaluationContext) ReleaseAllTempTableCharges()

func (ec *EvaluationContext) RowContext() *values.RowEvalContext

func (ec *EvaluationContext) RowContextPositional(pos values.OrdinalRow) *values.RowEvalContext

func (ec *EvaluationContext) Scratch() *ExecutionScratch

func (ec *EvaluationContext) StatementNow() time.Time

func (ec *EvaluationContext) WithBinding(id values.CorrelationIdentifier, val any) *EvaluationContext

func (ec *EvaluationContext) WithExecutionScratch(s *ExecutionScratch) *EvaluationContext

func (ec *EvaluationContext) WithMergedLegReadBypass(aliases ...string) *EvaluationContext

func (ec *EvaluationContext) WithMergedLegReadSink(sink *MergedLegReadSink) *EvaluationContext

func (ec *EvaluationContext) WithMergedLegWrongWindows() *EvaluationContext

func (ec *EvaluationContext) WithParams(params []any) *EvaluationContext

func (ec *EvaluationContext) WithScalarSubqueries(results map[values.CorrelationIdentifier]any) *EvaluationContext

func (ec *EvaluationContext) WithStatementTime(t time.Time) *EvaluationContext

type ExecutionScratch ¶

type ExecutionScratch struct {
	// contains filtered or unexported fields
}

ExecutionScratch is the statement-scoped home for operator resume state that is too large to serialize into every page's continuation.

WHY IT EXISTS. A continuation is normally self-contained: the operator packs whatever it needs to resume into bytes, and the bytes alone rebuild it. That is right when the state is O(1) — the streaming distinct's single previous key, a scan's position. It is quadratic when the state is O(rows already emitted), which is exactly the unordered hash distinct: its seen-set is the operator's whole memory, so page P's continuation would carry every key emitted through page P and a P-page drain would serialize and re-parse O(P^2) keys in total. Measured on a 401-page drain of 400 distinct values, the continuation grew 9 -> 1749 bytes and the drain re-parsed ~350 KB of keys to emit 400 rows.

The state cannot be shrunk: exact dedup over UNORDERED input fundamentally needs the set (an ordered input is the case that needs only the last key, and the planner already routes it to the streaming executor). Java declines to pay either cost — RecordQueryUnorderedPrimaryKeyDistinctPlan.java:100-104 mints `new HashSet<>()` per execution and passes the inner's continuation through untouched, so a duplicate spanning a resume is silently re-admitted. Go does not accept wrong rows, so the set has to survive the page boundary; the only remaining choice is whether it survives THROUGH bytes or BESIDE them. Beside them is the one that is not quadratic.

WHY IT IS SOUND. The bytes are round-tripped by exactly one production caller, the SQL statement's paging loop (cascades_generator.go), which re-executes the same plan against a fresh transaction to respect FDB's 5s bound. Its continuations never escape the statement: the driver rejects statement continuations outright (Go SQL tokens are engine-private and no resume entry point exists). So a statement-scoped side channel has exactly the lifetime the bytes do, and a resume that finds no scratch entry is an impossible state rather than a supported one — it is reported as an error, never deduped against an empty set.

THE INVARIANT THAT MAKES IT SAFE: **executing a page must be idempotent with respect to the scratch.** Lifetime is not the whole story — the same continuation bytes are not merely HELD for the statement, they are EXECUTED more than once. paginatingRows.fetchPage runs its whole body inside the FDB retry loop (runInCapturedTx -> DB.Run -> TransactCtx, fdb/database.go:323), which re-invokes the closure from the UNCHANGED r.continuation on any retryable error; the closure resets r.buf, so the failed attempt's rows are discarded. A scratch that let the failed attempt mutate shared state would therefore lose rows silently — the retry would treat the discarded attempt's values as already emitted. (Reproduced: a mid-drain abort on a 12-value fixture emitted 10, no error. The by-value encoding was immune by construction, because bytes are immutable.) Two rules restore it:

1. A published set is IMMUTABLE. A resumed cursor never touches the set it adopted; it accumulates its own page's new keys in a private delta and publishes base+delta as a NEW entry. A dying attempt then mutates nothing its retry can see. The base is never COPIED per page — that would restore the quadratic — it is extended in place exactly once, when rule 2 proves no one can reach its earlier form again.

2. Eviction keys on ADOPT, never on PARK. Reaching token T proves the page that minted T committed and was consumed, so T's predecessor is dead. MINTING T proves nothing: the attempt that minted it can still fail, and its retry resumes from the predecessor it was minted from. (Reproduced: park-time eviction turned a routine retryable error after a completed page into a hard "seen-set not held" failure.) Evicting on adopt keeps the bound at a couple of live entries per operator all the same.

RETIREMENT FOLLOWS NAMEABILITY. An entry must live exactly as long as some continuation the statement still holds can name its token — no longer, and not one moment less. Three earlier designs keyed retirement on a CURSOR LIFECYCLE EVENT instead, and each was wrong for its own reason. They are recorded because the wrong answer is the intuitive one:

• on PARK: a retry resumes the predecessor the failed attempt was minted from, so minting cannot retire it.
• on a page-local MARK of the surviving continuation: enclosing continuation objects cache their own bytes, so the final ToBytes need never call down and the mark is missed. It silently dropped rows.
• on EXHAUSTION: an enclosing operator can retain a child continuation OBJECT past the child's end and serialize it later — aggregateCursor.emitFinal emits its final row carrying a retained earlier inner position (streaming_cursors.go:393-401). A token minted before the inner ended is still named after it.

Object-graph reachability from the surviving continuation is what this WANTED to be, and the code forbids it: sixteen sites wrap a child by serializing it eagerly into a plain BytesContinuation (limitEnvelopeCursor, executor.go:2009, is the one that matters here), so the child object is dropped and no walk — however careful about byte caching — can see through it. Bytes are the only medium that survives, so ADOPTION is the only ground truth available: a page adopts exactly the entries its own continuation named. SweepAfterPage is built on that, at the cost of one page of lag, plus the exact case that needs no lag (an exhausted page names nothing at all).

"A page adopts exactly what its continuation names" has ONE hole, and it is plugged explicitly rather than argued away: a page can FORWARD a name instead of resolving it, handing bytes it received straight back out without ever building the cursor that would adopt them. holdForwardedName is how the forwarding site says so, and the sweep then judges nothing unreachable that page. A forwarded name is a name.

Residency is then bounded by that sweep plus two structural rules:

1. An entry belongs to a CURSOR, not to a continuation (the prefix length rides the continuation instead), so an operator that serializes a child continuation on EVERY emitted row adds one entry, not one per row.
2. Adoption evicts the predecessor and any sibling a failed attempt published from it, so a paging chain keeps two.

MEMORY. The statement is charged for exactly what the scratch holds: the COMMITTED BASE plus the LIVE DELTAS. A parked entry holds its delta's bytes for as long as it lives — the producing cursor hands its page charge over at park time instead of releasing it at close — and retirement gives them back. Folding charges the committed layer permanently, because that layer really is held for the statement.

Both halves are load-bearing and they cancel if only one is present, which is how they were both wrong at once while every test passed. Without the fold charge the committed set weighs nothing, so a high-cardinality DISTINCT can never trip the budget and the loud-failure promise is empty. Without every removal returning its bytes — and there are three doors out of s.distinct, so they all go through retire — the charge tracks how many PAGES a statement took rather than how much data it holds, and a retry-heavy or finely-paged statement fails for memory it does not have. Measured on 40 distinct values before the fix: 77 bytes at 1 row/page, 71 at 3, 59 at 10, and 0 in a single page.

Concurrency: the executor is single-threaded per statement (zero goroutine launches in this package, pinned by package_invariant_test.go), so the maps need no lock, exactly as ExecuteState's counters do not.

func NewExecutionScratch() *ExecutionScratch

func (s *ExecutionScratch) BeginPage()

func (s *ExecutionScratch) LiveDistinctSets() int

func (s *ExecutionScratch) MintedDistinctSets() int64

func (s *ExecutionScratch) PeakDistinctSets() int

func (s *ExecutionScratch) SweepAfterPage(exhausted bool)

type FilteredIndexPlanError ¶

type FilteredIndexPlanError struct {
	IndexName string
}

FilteredIndexPlanError reports a physical query plan that attempts to read a sparse/filtered index without carrying a predicate-implication proof. The planner currently excludes every filtered index from query candidates, so a plan that reaches this guard is hand-built or stale. Executing it would read only the predicate-selected subset and could silently omit records.

Low-level record-store APIs deliberately remain able to scan filtered indexes for maintenance and diagnostics. This is a query-plan invariant.

func (e *FilteredIndexPlanError) Error() string

type IncompatiblePhysicalComparandError ¶

type IncompatiblePhysicalComparandError struct {
	Component     int
	Comparison    predicates.ComparisonType
	PhysicalType  values.Type
	ProjectedType string
}

IncompatiblePhysicalComparandError reports an evaluated scan comparand that cannot inhabit the authoritative physical key component's tuple carrier. UNKNOWN parameters deliberately pass planner type gates, so this check must happen after valid packing-boundary coercions (numeric width and UUID) but before a mismatched tuple type code can turn SQL UNKNOWN into arbitrary rows.

func (e *IncompatiblePhysicalComparandError) Error() string

type InvalidScanComparisonShapeError ¶

type InvalidScanComparisonShapeError struct {
	Component int
	Detail    string
}

InvalidScanComparisonShapeError reports a comparison slice that cannot be represented by one contiguous tuple-key prefix: zero or more equalities, optionally one inequality component, and then only nil/Empty components. Silently stopping at the first gap or tail would discard a later predicate while presenting the scan as fully SARGed.

func (e *InvalidScanComparisonShapeError) Error() string

type InvalidScanRangeExecutionIdentityTypeError ¶

type InvalidScanRangeExecutionIdentityTypeError struct {
	Kind           ScanIdentityTypeErrorKind
	Implementation string
	Path           string
	ActivePath     string
}

InvalidScanRangeExecutionIdentityTypeError reports an invalid values.Type graph while a continuation fingerprint is being built. It deliberately records only concrete implementation names and structural paths: formatting the Type itself could invoke String on the same malformed graph and recurse.

func (e *InvalidScanRangeExecutionIdentityTypeError) Error() string

type LegColumnProvenanceFloors ¶

type LegColumnProvenanceFloors struct {
	// Calls floors the denominator every share is taken against.
	Calls int
	// DottedHitIdentityAvailable floors the population the retirement decision
	// is ABOUT. Calls alone does not cover it: the flat-hit arm carries 40 of
	// the 52 calls, so Calls can stay healthy while the dotted arm — the only
	// arm this census exists for — goes to zero.
	DottedHitIdentityAvailable int
}

LegColumnProvenanceFloors is the minimum population this census must report over a whole suite run.

It exists for the reason its two siblings' floors exist, and the reason is sharper here than for either of them. This census's entire finding is a pair of small numbers — the dotted arm answers FOUR times in the whole corpus, and all four have an identity available — and the retirement decision rests on BOTH halves: on the four being all there is, and on all four being identity-available. A zero population satisfies the second half vacuously. It also satisfies the DottedHitIdentityDiverged zero vacuously, and the partition as 0 == 0.

So a census that stopped being driven at all reports exactly the shape of a census reporting good news, and the numbers are small enough that "4" and "0" do not look different at a glance. The floors are what make them different.

Set at 1 rather than an order of magnitude below the measurement, because there is no order of magnitude here: the measured DottedHitIdentityAvailable is 4. What a floor detects at this scale is DISAPPEARANCE, which is the whole failure mode — the shapes that drive the dotted arm ceasing to be planned, or the reader ceasing to be reached.

type MaterializationLimitExceededError ¶

type MaterializationLimitExceededError struct {
	Limit   int
	Context string
}

MaterializationLimitExceededError is returned when an operator tries to buffer more rows in memory than the configured materialization limit.

func (e *MaterializationLimitExceededError) Error() string

type MergedLegBinding ¶

type MergedLegBinding struct {
	// OuterAlias is the FlatMap's own alias — the join whose merged row is being
	// decomposed. It is recorded because the join's-own-alias skip is decided
	// against it, and on the live shapes it never engages (the box's alias is not
	// any leg's alias), which is exactly the case the unit fixtures did not cover.
	OuterAlias string
	LegAlias   string
	Offset     int
	Width      int
}

The MERGED-LEG BINDING census: what bindMergedOuterLegs PRODUCED, and whether anything READ it.

It exists because those two are different questions and the answer differs. The binder was documented as having "no non-test consumer", which read as dormant. It is not dormant — it executes on the real-FDB corpus on every clustered-box gather, over ten thousand times in one sqldriver run. It also has a READER, on a multi-leg merged row: over that same run its bindings are looked up twelve times, every one of them on a merged row carrying SIBLING legs. What those reads are not is LOAD-BEARING — neither removing the bindings entirely nor aiming every window at a sibling leg's slots changes a single assertion, and both of those perturbations are performed by a standing test on every run rather than by hand.

A claim like that decays the moment someone adds a load-bearing consumer, and it decays SILENTLY — the binder keeps working, so nothing goes red, and the next person reads the stale claim and reasons from it. So the claim is measured here rather than asserted in a comment: the reads are counted, attributed to the merged row they came out of, and excused one shape at a time by a proof that re-runs. A read this census cannot match to such a proof turns the gate red and says what gets re-armed.

It is GATED on the same flag as the leg-identity census (values.LegIdentityCensusEnabled): the read side sits in EvaluationContext.GetCorrelationBinding, which is per-reference-per-row, and production must not pay a type assertion there.

type MergedLegReadSink ¶

type MergedLegReadSink struct {
	// contains filtered or unexported fields
}

MergedLegReadSink collects ONE execution's binder-window reads and declined lookups, in parallel with the process-global census.

It exists because the global census cannot answer "what did THIS execution do?". Its tallies are process-wide and the suite is parallel, so a before/after delta around one execution also picks up whatever a concurrently running test read in the same window — and the redundancy pin's whole method is to compare two executions of one query by what each of them read. A delta that a sibling test can perturb makes that comparison intermittently wrong in the direction of a spurious red.

The zero value is not usable; a nil *MergedLegReadSink is, and records nothing, so the read path can call through it unconditionally.

func NewMergedLegReadSink() *MergedLegReadSink

func (s *MergedLegReadSink) BypassOutcomes() (misses, handoffs map[MergedRowRead]int)

func (s *MergedLegReadSink) MisaimedReads() map[MergedRowRead]int

func (s *MergedLegReadSink) Reads() map[MergedRowRead]int

type MergedRowRead ¶

type MergedRowRead struct {
	Alias string
	// Shape is mergedRowShape of the merged row the read's window looked into.
	Shape string
}

MergedRowRead identifies a read that resolved to a binder-produced window on a MULTI-LEG merged row: the alias that was read, AND the LAYOUT of the merged row it was read out of.

The layout is carried because the alias alone is not an identity. Alias names COLLIDE across queries — the corpus binds twenty unrelated legs under the outer name `X` — which is why this census refuses to classify reads by alias. The same argument applies with full force to EXCUSING them: a proven-redundant entry keyed on the bare name `ST` excuses every future multi-leg read of anything called `ST`, including a load-bearing one in a query nobody has written yet. Keyed on (alias, shape) it excuses only what the proof actually covered.

type NumericRangeOverflowError ¶

type NumericRangeOverflowError struct {
	Value    any
	Column   string
	TypeName string
}

func (e *NumericRangeOverflowError) Error() string

type PositionalRow ¶

type PositionalRow struct {
	// Type gives each slot its name and type; Slots[i] is the value of the field
	// at ordinal i. len(Slots) == len(Type.Fields) for a well-formed row.
	Type  *values.RecordType
	Slots []any
}

PositionalRow is the typed positional runtime row — the SOLE runtime row: field values indexed by ORDINAL, paired with the RecordType that names and types each slot. Positional access (Slots[ordinal]) mirrors Java's MessageHelpers.getFieldValueForFieldOrdinals; every column reference reads its plan-time-baked ordinal (there is no runtime name resolution — the Type's names serve plan-time binding and diagnostics).

func NewPositionalRow(typ *values.RecordType) *PositionalRow

func (r *PositionalRow) Get(ordinal int) (any, bool)

func (r *PositionalRow) MultiLeg() bool

func (r *PositionalRow) Set(ordinal int, v any) bool

func (r *PositionalRow) TypeNames() []string

type QueryResult ¶

type QueryResult struct {
	// Positional is the ordinal-model row (a typed PositionalRow, field
	// values indexed by ordinal) — the SOLE runtime row. Every producer emits it
	// (scans/covering scans, projection/map, aggregate output, and join merges
	// via concatLegPositionals), and FieldValue resolution reads it by ordinal,
	// loud on a miss (OrdinalResolutionError). There is no name-keyed row model:
	// runtime name resolution would be first-match and silently wrong on
	// duplicate column names, where the plan-time ordinal is exact.
	Positional *PositionalRow
	Record     *recordlayer.FDBStoredRecord[proto.Message]
	PrimaryKey tuple.Tuple
}

QueryResult is the row type flowing through plan execution cursors. Wraps the ordinal-model row (Positional), an optional stored record (when the row originated from a scan), and an optional primary key. Mirrors Java's QueryResult.

func CollectAll(ctx context.Context, cursor recordlayer.RecordCursor[QueryResult]) ([]QueryResult, error)

func CollectAllBounded(ctx context.Context, cursor recordlayer.RecordCursor[QueryResult], st *recordlayer.ExecuteState, limit int, opName string) ([]QueryResult, int64, error)

func FromStoredRecord(rec *recordlayer.FDBStoredRecord[proto.Message]) QueryResult

type RecordLayerResultSet ¶

type RecordLayerResultSet struct {
	// contains filtered or unexported fields
}

RecordLayerResultSet wraps a RecordCursor[QueryResult] and implements api.ResultSet. Mirrors Java's RecordLayerResultSet: Next() advances the cursor, typed accessors read from the current row's positional slots.

Column metadata is provided at construction time (derived from the plan's result type or the schema catalog). Column accessors are 1-indexed per JDBC convention.

func NewRecordLayerResultSet(
	ctx context.Context,
	cursor recordlayer.RecordCursor[QueryResult],
	columns []ColumnDef,
) *RecordLayerResultSet

func (rs *RecordLayerResultSet) Boolean(columnIndex int) (bool, error)

func (rs *RecordLayerResultSet) BooleanByName(name string) (bool, error)

func (rs *RecordLayerResultSet) Bytes(columnIndex int) ([]byte, error)

func (rs *RecordLayerResultSet) BytesByName(name string) ([]byte, error)

func (rs *RecordLayerResultSet) Close() error

func (rs *RecordLayerResultSet) Continuation() (api.Continuation, error)

func (rs *RecordLayerResultSet) Double(columnIndex int) (float64, error)

func (rs *RecordLayerResultSet) Err() error

func (rs *RecordLayerResultSet) Float(columnIndex int) (float32, error)

func (rs *RecordLayerResultSet) GetContinuation() recordlayer.RecordCursorContinuation

func (rs *RecordLayerResultSet) GetNoNextReason() recordlayer.NoNextReason

func (rs *RecordLayerResultSet) Long(columnIndex int) (int64, error)

func (rs *RecordLayerResultSet) LongByName(name string) (int64, error)

func (rs *RecordLayerResultSet) MetaData() api.ResultSetMetaData

func (rs *RecordLayerResultSet) Next() bool

func (rs *RecordLayerResultSet) Object(columnIndex int) (any, error)

func (rs *RecordLayerResultSet) ObjectByName(name string) (any, error)

func (rs *RecordLayerResultSet) String(columnIndex int) (string, error)

func (rs *RecordLayerResultSet) StringByName(name string) (string, error)

func (rs *RecordLayerResultSet) WasNull() bool

type RecursiveCTEDepthExceededError ¶

type RecursiveCTEDepthExceededError struct {
	MaxDepth int
}

func (e *RecursiveCTEDepthExceededError) Error() string

type ScanIdentityTypeErrorKind ¶

type ScanIdentityTypeErrorKind uint8

ScanIdentityTypeErrorKind identifies why a values.Type cannot safely participate in a scan continuation identity. The encoder accepts arbitrary implementations of values.Type, including hand-built plans, so it must reject interface values that would otherwise panic or recurse without end.

const (
	ScanIdentityTypeErrorTypedNil ScanIdentityTypeErrorKind = iota + 1
	ScanIdentityTypeErrorCycle
)

type SortBufferExceededError ¶

type SortBufferExceededError struct {
	Rows  int
	Limit int
}

SortBufferExceededError is returned when an in-memory sort materializes more rows than the configured limit. Prevents OOM on unbounded ORDER BY without LIMIT.

func (e *SortBufferExceededError) Error() string

type SumOverflowError ¶

type SumOverflowError struct{ Int32 bool }

SumOverflowError reports a SUM/AVG accumulation leaving its operator's integer domain. Int32 selects the SUM_I/AVG_I lane's message: Java's Math.addExact(int, int) throws ArithmeticException("integer overflow") where the long overload throws "long overflow", and the messages surface verbatim through the driver (both under SQLSTATE 22003).

func (e *SumOverflowError) Error() string

type TempTable ¶

type TempTable struct {
	// contains filtered or unexported fields
}

TempTable is an in-memory list of QueryResult used by TempTableInsertPlan and TempTableScanPlan. Mirrors Java's com.apple.foundationdb.record.TempTable.

RFC-130: a TempTable is a cardinality-growing buffer — the recursive-CTE per-level working set (ping-ponged scan/insert tables) and the TempTableInsertPlan target both accumulate into it, separate from the CollectAllBounded per-level materialization. It carries the statement's always-present *ExecuteState (st) and charges each appended row's byte estimate in Add. The pre-existing sync.Mutex is defensive (the zero- goroutine executor invariant makes it currently moot); charging under the lock is correct regardless — if the executor ever goes concurrent the pinned package_invariant_test fires and ChargeMemory moves to atomic.

func NewTempTable() *TempTable

func NewTempTableWithState(st *recordlayer.ExecuteState) *TempTable

func (tt *TempTable) Add(qr QueryResult) error

func (tt *TempTable) Clear()

func (tt *TempTable) GetList() []QueryResult

func (tt *TempTable) ReleaseCharges()

func (tt *TempTable) ReplaceList(rows []QueryResult)

func (tt *TempTable) Snapshot() []QueryResult

type UnknownPhysicalKeyTypeError ¶

type UnknownPhysicalKeyTypeError struct {
	Component  int
	Comparison predicates.ComparisonType
}

UnknownPhysicalKeyTypeError reports a non-null scan comparand for which the chosen physical plan did not carry an authoritative key-component type. Tuple encoding is selected by the Go runtime carrier, so guessing from an operand declaration or evaluated parameter can probe a different tuple type code than the stored key (most notably FLOAT versus DOUBLE). Type-independent NULL cases are handled before this error is considered.

func (e *UnknownPhysicalKeyTypeError) Error() string

type UnsupportedContinuationError ¶

type UnsupportedContinuationError struct {
	Shape string
}

UnsupportedContinuationError reports a resume attempt on a cursor shape that has no continuation support yet (RFC-180 WS-A follow-ups). The driver maps it to SQLSTATE 0A000 — a typed decline, never a silent wrong start (before RFC-180 the buffered union fed the PARENT's continuation to every child; a raw-key scan child consumed it as a scan position).

func (e *UnsupportedContinuationError) Error() string

type UnsupportedPhysicalFloatEquivalenceError ¶

type UnsupportedPhysicalFloatEquivalenceError struct {
	Component    int
	Comparison   predicates.ComparisonType
	PhysicalType values.Type
}

UnsupportedPhysicalFloatEquivalenceError reports a floating-point scan comparand whose logical equality class cannot yet be represented exactly by this physical range binder. FDB tuple keys preserve every NaN sign/payload, while the query value comparator treats NaNs as one logical value. Probing the evaluated payload would silently miss equal keys, so an already-chosen dynamic index access fails before opening storage.

func (e *UnsupportedPhysicalFloatEquivalenceError) Error() string

type UnsupportedPhysicalKeyTypeError ¶

type UnsupportedPhysicalKeyTypeError struct {
	Component    int
	Comparison   predicates.ComparisonType
	PhysicalType values.Type
}

UnsupportedPhysicalKeyTypeError reports physical metadata that names a placeholder or structured logical type rather than one concrete scalar FDB tuple carrier. Presence is not authority: ANY, NULL, NONE, RECORD, ARRAY, RELATION, and ENUM do not specify how a query comparand was encoded in the key. Production metadata maps enum fields to their LONG wire carrier; a hand-built/stale plan that carries ENUM itself must therefore fail closed.

func (e *UnsupportedPhysicalKeyTypeError) Error() string

type UnsupportedPhysicalNumericProjectionError ¶

type UnsupportedPhysicalNumericProjectionError struct {
	Component            int
	Comparison           predicates.ComparisonType
	PhysicalType         values.Type
	EquivalenceClassLow  int64
	EquivalenceClassHigh int64
}

UnsupportedPhysicalNumericProjectionError reports a floating-point comparand whose logical equality class contains more than one value in an authoritative physical integer key domain. The scan plan's fixed-key and one-row proofs are valid only when every successful equality binding selects at most one physical integer key. Returning this error before storage is therefore preferable to silently probing one representative of a larger cmpAny equivalence class.

The class can contain multiple integers because cmpAny compares a mixed integer/float pair after converting the integer to float64. For example, both 2^53 and 2^53+1 compare equal to float64(2^53). Ordered comparisons do not use this error: their monotone inverse is projected to an exact inclusive integer interval by projectFloatComparisonToIntegerDomain.

func (e *UnsupportedPhysicalNumericProjectionError) Error() string

type UnsupportedPhysicalStartsWithError ¶

type UnsupportedPhysicalStartsWithError struct {
	Component    int
	PhysicalType values.Type
}

UnsupportedPhysicalStartsWithError reports a STARTS_WITH comparison whose authoritative physical key component is not STRING. PREFIX_STRING tuple endpoints describe a byte prefix of a packed string element; applying them to another carrier (including BYTES, or the string-backed DATE/TIMESTAMP logical types) does not implement Comparison.Eval's string/string STARTS_WITH truth table. Such a plan must fail before opening storage rather than silently treating an operator/type mismatch as a compensated range.

func (e *UnsupportedPhysicalStartsWithError) Error() string