values

type AggregateEvalError ¶

type AggregateEvalError struct {
	Message string
}

AggregateEvalError is returned by AggregateValue.Evaluate when an aggregate node is reached on the per-row scalar evaluation path — e.g. an aggregate used in WHERE (`WHERE COUNT(*) > 0`). Java rejects this shape at plan time ("unable to eval an aggregation function with eval()"); Go's planner does not yet (TODO: plan-time rejection of aggregate-in-scalar-context), so the misuse reaches row eval. It is genuinely reachable from user query data, so it must return an error rather than panic (RFC-087 residual-panic audit, gate #1). The executor maps this to SQLSTATE 42803 (grouping error).

func (e *AggregateEvalError) Error() string

type AggregateOp ¶

type AggregateOp int

AggregateOp identifies an aggregate function. Mirrors the subset of Java's `AggregateValue` that the embedded engine currently lowers to a Record Layer aggregate-index query.

const (
	AggInvalid   AggregateOp = iota // unassigned — rejects if ever evaluated
	AggCount                        // COUNT(expr)
	AggCountStar                    // COUNT(*)
	AggSum                          // SUM(expr)
	AggMin                          // MIN(expr)
	AggMax                          // MAX(expr)
	AggAvg                          // AVG(expr) — rejects at Evaluate, no streaming impl
)

func (op AggregateOp) Symbol() string

type AggregateValue ¶

type AggregateValue struct {
	Op      AggregateOp
	Operand Value // nil iff Op == AggCountStar
}

AggregateValue represents an aggregate function application — `COUNT(*)`, `SUM(col)`, `MIN(expr)`, etc. The Operand is the argument (nil for COUNT(*)); the Op identifies which aggregate.

AggregateValue does NOT implement per-row Evaluate — aggregates span rows and need an accumulator. Evaluate returns nil to make the ignore-of-row-context explicit; rule code identifies AggregateValues by type-assertion and routes them to the aggregate operator (hash-agg, streaming-agg, index-backed agg) at build time.

func NewAggregateValue(op AggregateOp, operand Value) *AggregateValue

func (a *AggregateValue) Children() []Value

func (a *AggregateValue) Evaluate(any) (any, error)

func (a *AggregateValue) GetIndexTypeName() string

AggCount     → COUNT_NOT_NULL  (counts non-null values)
AggCountStar → COUNT           (counts all rows incl. NULL)
AggSum       → SUM
AggMin       → MIN_EVER_LONG   (or MIN_EVER_TUPLE for non-numeric)
AggMax       → MAX_EVER_LONG   (or MAX_EVER_TUPLE)
AggAvg       → ""              (no direct index — computed from
                                 SUM/COUNT pair instead)
AggInvalid   → ""

func (*AggregateValue) IsNonEvaluable() bool

func (*AggregateValue) Name() string

func (a *AggregateValue) Type() Type

type AliasMap ¶

type AliasMap map[CorrelationIdentifier]CorrelationIdentifier

AliasMap maps old correlation identifiers to new ones. Used during plan construction when a quantifier's alias changes and downstream values need to reference the new alias.

type AnchoredJoinLeg ¶

type AnchoredJoinLeg struct {
	Alias   CorrelationIdentifier
	Columns []Field
}

AnchoredJoinLeg is one source leg of a source-anchored join result (RFC-077): a quantifier alias and the columns its result row carries (name + type).

type AndOrOp ¶

type AndOrOp int

AndOrOp identifies the boolean connector. Mirrors Java's `AndOrValue.Operator` enum.

const (
	// AndOrAnd is short-circuit logical AND with Kleene 3VL.
	AndOrAnd AndOrOp = iota
	// AndOrOr is short-circuit logical OR with Kleene 3VL.
	AndOrOr
)

func (op AndOrOp) String() string

type AndOrValue ¶

type AndOrValue struct {
	Op    AndOrOp
	Left  Value
	Right Value
}

AndOrValue is the Value-layer AND/OR connector — binary boolean operator with Kleene three-valued logic semantics. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.AndOrValue`.

Java has parallel predicate-layer AndPredicate / OrPredicate (already ported); this Value-layer variant exists for cases where AND/OR appears in a NON-predicate context — typically SQL projections like `SELECT a AND b FROM t` where the connector itself is the row's emitted Value, not a filter.

Result type: NotNullBoolean when both operands are NOT NULL, else NullableBoolean (per SQL Kleene rules — TRUE OR NULL = TRUE, FALSE AND NULL = FALSE, but TRUE AND NULL = NULL).

Eval semantics (Kleene 3VL):

AND        | TRUE  FALSE NULL
-----------|-------------------
TRUE       | TRUE  FALSE NULL
FALSE      | FALSE FALSE FALSE
NULL       | NULL  FALSE NULL

OR         | TRUE  FALSE NULL
-----------|-------------------
TRUE       | TRUE  TRUE  TRUE
FALSE      | TRUE  FALSE NULL
NULL       | TRUE  NULL  NULL

Short-circuit: if the LEFT operand evaluates to the dominant value (FALSE for AND, TRUE for OR), the right operand is not evaluated. Mirrors Java's eval-side optimisation. The right is evaluated for non-dominant left values (including NULL).

Non-bool operand handling: if either operand evaluates to a non- bool / non-NULL value, eval returns nil (UNKNOWN — type-degraded).

func NewAndOrValue(op AndOrOp, left, right Value) *AndOrValue

func (v *AndOrValue) Children() []Value

func (v *AndOrValue) Evaluate(evalCtx any) (any, error)

func (v *AndOrValue) Name() string

func (v *AndOrValue) Type() Type

func (v *AndOrValue) WithChildren(newChildren []Value) *AndOrValue

type ArithmeticDivisionByZeroError ¶

type ArithmeticDivisionByZeroError struct{}

ArithmeticDivisionByZeroError is returned by ArithmeticValue.Evaluate when division or modulo by zero is attempted. Callers (the executor) convert this to the appropriate SQL error.

func (*ArithmeticDivisionByZeroError) Error() string

type ArithmeticOp ¶

type ArithmeticOp int

ArithmeticOp is a subset of SQL arithmetic — enough to build a non-trivial matcher.

const (
	OpAdd ArithmeticOp = iota
	OpSub
	OpMul
	OpDiv
	OpMod
)

func (o ArithmeticOp) Symbol() string

type ArithmeticOverflowError ¶

type ArithmeticOverflowError struct{}

ArithmeticOverflowError is returned by ArithmeticValue.Evaluate when integer arithmetic overflows. Callers (the executor) convert this to SQLSTATE 22003 NUMERIC_VALUE_OUT_OF_RANGE.

func (*ArithmeticOverflowError) Error() string

type ArithmeticValue ¶

type ArithmeticValue struct {
	Op    ArithmeticOp
	Left  Value
	Right Value
}

ArithmeticValue is a binary arithmetic over two child Values. Evaluate recurses left + right and applies the op with numeric promotion (float arithmetic when either operand is float64, else int64; mixed non-numeric operands are a ScalarTypeMismatchError). NULL on either side propagates (SQL semantics). Division by zero returns nil (UNKNOWN).

func (a *ArithmeticValue) Children() []Value

func (a *ArithmeticValue) Evaluate(evalCtx any) (any, error)

func (a *ArithmeticValue) Name() string

func (a *ArithmeticValue) Type() Type

type ArrayConstructorValue ¶

type ArrayConstructorValue struct {
	ElementType Type
	Elements    []Value
}

ArrayConstructorValue evaluates an N-element ARRAY[a, b, c, ...] SQL literal — gathers each child Value's evaluation into a `[]any` representing the array. Mirrors Java's `LightArrayConstructorValue` (the simple, non-protobuf-message variant of `AbstractArrayConstructorValue`).

All children must produce values compatible with the declared `ElementType`. Go does NOT enforce per-element type validation at construction — Java's `injectPromotions` chain handles type-coercion via `PromoteValue` wrappers; the planner is expected to pre-resolve children to compatible types before reaching this constructor. Mismatched child types surface at evaluation as nil-typed elements in the produced slice.

Result type: nullable Array(ElementType). Java's getResultType() returns `Type.Array(elementType)` (always non-nullable since the constructor produces a concrete array literal); Go matches by emitting `&ArrayType{Nullable: false, ElementType: ...}`.

Empty-array case: an array constructor with zero children produces an empty slice (NOT nil) — Java's eval likewise returns `ImmutableList.of()`. This distinguishes "empty array" from "NULL array" — important for SQL CARDINALITY / ARRAY_LENGTH operations where empty has length 0 and NULL has length NULL.

func NewArrayConstructorValue(elementType Type, elements []Value) *ArrayConstructorValue

func (v *ArrayConstructorValue) Children() []Value

func (v *ArrayConstructorValue) Evaluate(evalCtx any) (any, error)

func (*ArrayConstructorValue) Name() string

func (v *ArrayConstructorValue) Type() Type

func (v *ArrayConstructorValue) WithChildren(newChildren []Value) *ArrayConstructorValue

type ArrayDistinctValue ¶

type ArrayDistinctValue struct {
	Child Value
	// Typ is the result Type — matches Child's Type for arrays.
	// Defaults to UnknownType if not set.
	Typ Type
}

ArrayDistinctValue is the SQL `ARRAY_DISTINCT` operator: yields the input array with duplicate elements removed (preserving the first-occurrence order of the original). Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values. ArrayDistinctValue`.

CONFORMANCE: matches Java's eval — returns the input list with `Stream.distinct()` applied (first-seen order). NULL input propagates to NULL.

Type matches the Child's array Type (Go assumes the Child produces an array — Java's constructor `Verify.verify(innerResultType.isArray())` enforces this; Go accepts a Value of any Type but the Evaluate degrades to nil if Child doesn't return a slice).

func NewArrayDistinctValue(child Value) *ArrayDistinctValue

func (v *ArrayDistinctValue) Children() []Value

func (v *ArrayDistinctValue) Evaluate(evalCtx any) (any, error)

func (*ArrayDistinctValue) Name() string

func (v *ArrayDistinctValue) Type() Type

type ArrayType ¶

type ArrayType struct {
	// Nullable reports whether the array column allows NULL.
	Nullable bool
	// ElementType is the type of the array's values. May be nil
	// when type inference hasn't filled it in (typically transient
	// during plan-time analysis; runtime arrays always have a
	// concrete element type by the time they're evaluated).
	ElementType Type
}

ArrayType is the Type impl for ordered collections. Mirrors Java's Array nested type. Carries an ElementType (the type of the array's values) plus a Nullable flag (whether the array column itself can be NULL).

Two ArrayType instances are Equal iff their Nullable + ElementType match. nil ElementType represents an array whose element type isn't inferred yet (e.g. an empty array literal pre-type-inference) and is equal only to another ArrayType with nil ElementType.

func NewArrayType(nullable bool, elementType Type) *ArrayType

func (*ArrayType) Code() TypeCode

func (a *ArrayType) Equals(other Type) bool

func (a *ArrayType) IsErased() bool

func (a *ArrayType) IsNullable() bool

func (a *ArrayType) String() string

type BakedNameContextError ¶

type BakedNameContextError struct {
	Field   string
	Ordinal int
}

BakedNameContextError reports a BAKED FieldValue (ordinal authoritative) evaluated against a NAME-keyed or unrecognized row context outside the §5 oracle. Never a silent name read or silent NULL: the display name is diagnostics-only and resolving by it would return the FIRST of duplicate same-named columns — the conflation RFC-173 exists to kill. (A nil context stays NULL — that is the sanctioned appendNullLeg / nil-binding path, contract ruling #3.)

func (e *BakedNameContextError) Error() string

type BooleanValue ¶

type BooleanValue struct {
	Value *bool // nil = UNKNOWN
}

BooleanValue is a literal true / false (and NULL when Value is nil — SQL UNKNOWN at the Value layer).

NAMING CAVEAT: Java has a `BooleanValue` of the same name but it's an INTERFACE (Value→QueryPredicate translation shim), not a concrete type. The Go-side concrete is closer to Java's `LiteralValue<Boolean>`. The name collision is regrettable but the Go code references this concrete type explicitly; rule code should not pattern-match on `*BooleanValue` thinking it has Java's interface semantics.

func NewBooleanValue(v bool) *BooleanValue

func (*BooleanValue) Children() []Value

func (b *BooleanValue) Evaluate(any) (any, error)

func (*BooleanValue) Name() string

func (b *BooleanValue) Type() Type

type CardinalityValue ¶

type CardinalityValue struct {
	Child Value
}

CardinalityValue is the SQL `CARDINALITY` operator: yields the number of elements in an array. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values. CardinalityValue`.

CARDINALITY(arr)  ↔  CardinalityValue{Child: arr}

CONFORMANCE: matches Java's eval — returns the array length as an integer. NULL array → NULL (Java: childResult == null ? null : size()).

The result Type is a nullable 32-bit INT — Java's `Type.primitiveType(Type.TypeCode.INT)` ("array indexes and sizes are 32-bit integers"), nullable because a NULL array yields NULL. The metadata layer reports this column as INTEGER.

Java's ctor asserts the child is array-typed (`SemanticException.check(childValue.getResultType().isArray(), INCOMPATIBLE_TYPE)`). In Go the array-type validation lives at the SQL walk site (expr.walkCardinality), the earliest point with the resolved argument Type and access to the SQLSTATE error codes — a non-array argument raises CANNOT_CONVERT_TYPE there, matching the yamsql. This constructor stays a permissive data builder so the tree-rewrite machinery (withChildren) can reconstruct the node without re-validating.

func NewCardinalityValue(child Value) *CardinalityValue

func (v *CardinalityValue) Children() []Value

func (v *CardinalityValue) Evaluate(evalCtx any) (any, error)

func (*CardinalityValue) Name() string

func (*CardinalityValue) Type() Type

type CastValue ¶

type CastValue struct {
	Child  Value
	Target Type
}

CastValue converts a child Value's result to a target Type. Go handles the trivial conversions our existing corpus needs: int ↔ string (via strconv-free formatting), bool ↔ int (false=0, true=1). Unknown conversions return nil (UNKNOWN) — extend the Evaluate switch when a corpus query needs a new pair.

func NewCastValue(child Value, target Type) *CastValue

func (c *CastValue) Children() []Value

func (c *CastValue) Evaluate(evalCtx any) (any, error)

func (c *CastValue) Name() string

func (c *CastValue) Type() Type

type CollateValue ¶

type CollateValue struct {
	StringChild   Value
	LocaleChild   Value // nil = use registry default locale
	StrengthChild Value // nil = use registry default strength
}

CollateValue applies a locale-specific collation to a string, producing a sort-key BYTES blob suitable for use as part of an index key. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.CollateValue`.

SQL surface:

collate(name, 'en_US', 'PRIMARY')
      ↑ string  ↑ locale  ↑ strength

Locale and strength are optional — Java's grammar allows `collate(name)`, `collate(name, locale)`, or `collate(name, locale, strength)`.

Strength enum (mirrors java.text.Collator):

• PRIMARY: only base-letter differences matter ('a' = 'A', 'a' ≠ 'b').
• SECONDARY: + accent differences ('a' ≠ 'á', 'a' = 'A').
• TERTIARY: + case differences ('a' ≠ 'A').
• IDENTICAL: full Unicode normalisation.

Used in collation-aware sort + comparison: the produced BYTES blob is a normalised sort key — sorting / comparing the keys lexicographically reproduces locale-aware ordering.

Result type: NotNullBytes. Even when the input string is NULL, the produced sort key is a sentinel byte sequence (Java's behaviour); Go surfaces nil in that branch (no sentinel).

Eval is a placeholder: the collation machinery exists on the index side (pkg/recordlayer/collate_function_key_expression.go wires golang.org/x/text/collate) but is NOT wired into this Value's Evaluate. The Value-shape is reachable for parser / planner / serialisation work; a query that needs runtime COLLATE evaluation must wire that machinery through here first.

func NewCollateValue(stringChild, localeChild, strengthChild Value) *CollateValue

func (v *CollateValue) Children() []Value

func (*CollateValue) Evaluate(any) (any, error)

func (*CollateValue) Name() string

func (*CollateValue) Type() Type

func (v *CollateValue) WithChildren(newChildren []Value) *CollateValue

type ConditionSelectorValue ¶

type ConditionSelectorValue struct {
	Implications []Value
}

ConditionSelectorValue evaluates a list of boolean "implication" Values in order and returns the 0-based INDEX of the first TRUE implication. Returns nil if no implication evaluates TRUE. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.ConditionSelectorValue`.

Companion to PickValue: together they implement SQL CASE expressions:

CASE WHEN c1 THEN v1
     WHEN c2 THEN v2
     ELSE def END
  ↓ Cascades planner lowering
PickValue(
  selector = ConditionSelectorValue(c1, c2, TRUE),
  alternatives = [v1, v2, def],
  type = inferredType,
)

The trailing TRUE implication captures the implicit ELSE — the selector returns the def's index when no earlier predicate matches.

Result type: INT (NotNullInt — except when no implication matches, where eval returns nil; the type is still INT as a discriminator even though the value can be NULL at runtime).

Eval contract:

• Walks each implication in source order.
• First implication that evaluates TRUE → returns its 0-based index as int64.
• All implications FALSE / NULL / non-bool → returns nil.

Per Java's eval, only Boolean.TRUE matches — Boolean.FALSE and non-boolean / null results don't trigger the index return.

func NewConditionSelectorValue(implications []Value) *ConditionSelectorValue

func (v *ConditionSelectorValue) Children() []Value

func (v *ConditionSelectorValue) Evaluate(evalCtx any) (any, error)

func (*ConditionSelectorValue) Name() string

func (*ConditionSelectorValue) Type() Type

func (v *ConditionSelectorValue) WithChildren(newChildren []Value) *ConditionSelectorValue

type ConstantDeref ¶

type ConstantDeref interface {
	// DereferenceConstant returns the value bound to (alias,
	// constantID) at evaluation time, or nil if no binding exists.
	DereferenceConstant(alias CorrelationIdentifier, constantID string) any
}

ConstantDeref is the optional EvaluationContext capability for dereferencing a ConstantObjectValue. Implementations look up the constant by (alias, constantID) in the planner's per-alias constant map.

Mirrors Java's EvaluationContext.dereferenceConstant.

type ConstantObjectValue ¶

type ConstantObjectValue struct {
	Alias      CorrelationIdentifier
	ConstantID string
	ResultType Type
}

ConstantObjectValue is a NAMED reference to a constant captured during planning. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values. ConstantObjectValue`.

The constant value itself is stored in an EvaluationContext at execution time, keyed by (alias, constantId). At plan-time the Value carries only the placeholder reference + the bound Type; the actual value is dereferenced when Evaluate runs against an EvaluationContext.

Why a named placeholder instead of a literal: parameter binding, plan-cache reuse, and constant capture during query rewriting all need to defer the actual constant until execution-time. Plan-time rewrites operate on the placeholder; execution dereferences.

Type is whatever the planner determined at capture time — typically nullable to allow NULL constants.

CONFORMANCE NOTE: Java's eval consults EvaluationContext.dereferenceConstant + PromoteValue.isPromotionNeeded for type promotion when the runtime constant's type doesn't match the bound result type. Go's Evaluate matches Java 1:1: dereference the constant, then apply promoteConstant when the runtime type differs from ResultType.

func NewConstantObjectValue(alias CorrelationIdentifier, constantID string, resultType Type) *ConstantObjectValue

func (*ConstantObjectValue) Children() []Value

func (v *ConstantObjectValue) Evaluate(evalCtx any) (any, error)

func (v *ConstantObjectValue) GetCorrelatedTo() map[CorrelationIdentifier]struct{}

func (*ConstantObjectValue) Name() string

func (v *ConstantObjectValue) Type() Type

type ConstantValue ¶

type ConstantValue struct {
	Value any
	Typ   Type
}

ConstantValue is a literal. Evaluate returns Value verbatim.

Typ carries the literal's rich Type. NULL constants (`Value == nil`) keep Typ for the typed-NULL case (e.g. `CAST(NULL AS INT)`); the constructor / call sites set the canonical singleton appropriate for the literal's Go runtime type.

func (c *ConstantValue) Children() []Value

func (c *ConstantValue) Evaluate(any) (any, error)

func (c *ConstantValue) Name() string

func (c *ConstantValue) Type() Type

type Correlated ¶

type Correlated interface {
	// GetCorrelatedTo returns the set of Quantifier IDs this value
	// references. A "leaf" value (ConstantValue) returns an empty
	// set. A FieldValue on Quantifier q returns {q}.
	GetCorrelatedTo() map[CorrelationIdentifier]struct{}
}

Correlated is the interface Java's `Correlated<T>` maps to. A Correlated value knows which CorrelationIdentifiers it depends on, and can rebind them (used by TranslationMap rewrites). Correlation-bearing Values and Predicates implement it.

type CorrelationBinder ¶

type CorrelationBinder interface {
	GetCorrelationBinding(id CorrelationIdentifier) (any, bool)
}

CorrelationBinder is an optional eval-context capability for resolving correlation bindings. When QuantifiedObjectValue.Evaluate is called with a context implementing this interface, it resolves the correlated row. Mirrors Java's EvaluationContext.getBinding(CORRELATION, alias).

type CorrelationIdentifier ¶

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

CorrelationIdentifier is an opaque alias for a Quantifier — two distinct Quantifiers get distinct IDs. Comparable by value (underlying string) so CorrelationIdentifiers can live in maps.

func NamedCorrelationIdentifier(name string) CorrelationIdentifier

func UniqueCorrelationIdentifier() CorrelationIdentifier

func UniqueUnmatchedID() CorrelationIdentifier

func (c CorrelationIdentifier) IsZero() bool

func (c CorrelationIdentifier) Name() string

func (c CorrelationIdentifier) String() string

type CosineDistanceRowNumberValue ¶

type CosineDistanceRowNumberValue struct {
	WindowedValue
}

CosineDistanceRowNumberValue is the cosine-distance K-NN ROW_NUMBER() window function. Assigns unique sequential row numbers (1-based) ordered by cosine distance from a reference vector. More similar vectors (smaller cosine distance) get lower numbers.

Mirrors Java's com.apple.foundationdb.record.query.plan.cascades.values.CosineDistanceRowNumberValue — a concrete WindowedValue + IndexOnlyValue subclass.

Cosine distance measures angular difference: 0 = identical direction, 1 = orthogonal, 2 = opposite.

This value is index-only: the row number is computed during HNSW index traversal, not from base records.

Result type: NotNullLong.

func NewCosineDistanceRowNumberValue(partitioningValues, argumentValues []Value) *CosineDistanceRowNumberValue

func (*CosineDistanceRowNumberValue) Evaluate(evalCtx any) (any, error)

func (*CosineDistanceRowNumberValue) IsIndexOnly() bool

func (*CosineDistanceRowNumberValue) Name() string

func (*CosineDistanceRowNumberValue) Type() Type

func (v *CosineDistanceRowNumberValue) WithChildren(newChildren []Value) *CosineDistanceRowNumberValue

type DerivedValue ¶

type DerivedValue struct {
	ChildrenList []Value
	ResultType   Type
}

DerivedValue is a placeholder Value that wraps a list of children without computing a result. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.DerivedValue`.

Used by:

• The planner during plan rewrites that need to track child dependencies but don't yet know how to compute a result.
• Match-candidate compatibility checks that consult the derived-from-which-children property.

DerivedValue is "non-evaluable" — Evaluate panics. Pattern-match against it; don't try to run it at the per-row level.

func NewDerivedValue(children []Value) *DerivedValue

func NewDerivedValueWithType(children []Value, resultType Type) *DerivedValue

func (v *DerivedValue) Children() []Value

func (*DerivedValue) Evaluate(any) (any, error)

func (*DerivedValue) Name() string

func (v *DerivedValue) Type() Type

type DistanceOperator ¶

type DistanceOperator int

DistanceOperator enumerates the vector-distance metrics SQL can invoke as scalar functions over vector-typed columns. Mirrors Java's `DistanceValue.DistanceOperator` verbatim — the SQL infix notation matches Java's enum names lowered.

const (
	// DistanceEuclidean is sqrt(sum((a_i - b_i)^2)) — L2 distance.
	DistanceEuclidean DistanceOperator = iota
	// DistanceEuclideanSquare is sum((a_i - b_i)^2) — squared L2,
	// avoids the sqrt for speed (same ordering as L2 for KNN).
	DistanceEuclideanSquare
	// DistanceCosine is 1 - (a·b)/(|a|·|b|) — angle-based; range [0, 2].
	DistanceCosine
	// DistanceDotProduct is -(a·b) — negated dot product so smaller
	// values = MORE similar (matches the "distance" convention where
	// 0 = identical).
	DistanceDotProduct
)

func (op DistanceOperator) String() string

type DistanceRowNumberValue ¶

type DistanceRowNumberValue struct {
	WindowedValue
	Metric             DistanceOperator
	EfSearch           *int
	IsReturningVectors *bool
}

DistanceRowNumberValue is the K-NN search Value: ROW_NUMBER() computed within an HNSW vector index traversal, ORDERED BY a specific distance metric. Mirrors Java's `EuclideanDistanceRowNumberValue` / `EuclideanSquareDistanceRowNumberValue` / `CosineDistanceRowNumberValue` / `DotProductDistanceRowNumberValue` — Java has FOUR concrete classes, one per metric.

The Go port UNIFIES the four into a single concrete type with a `Metric` field discriminator. The Java distinction matters because the K-NN match rule selects on the concrete class type; the Go unified design makes K-NN rules switch on Metric instead (a one-line `if v.Metric == DistanceCosine`-style check). Both expressions are equally matchable; the unified design avoids 4× class-per-metric duplication.

Used by the HNSW K-NN search-rewrite rule: when a query of the form

ROW_NUMBER() OVER (PARTITION BY ... ORDER BY <metric>(field, queryVec)) <= K

is detected, the planner rewrites it into a ScanIndex over the HNSW index with a DistanceRankValueComparison capturing K + queryVec; the resulting plan emits row-numbered candidates from the index's graph traversal directly. This Value is the post-rewrite shape — its eval is INDEX-ONLY (the ROW_NUMBER value is computed during the index search, not from the base record).

Result type: NotNullLong. ROW_NUMBER is always populated, 1-based.

The HNSW config (EfSearch + IsReturningVectors) carries through from the higher-order ROW_NUMBER form — same fields as RowNumberValue's HNSW knobs.

func NewDistanceRowNumberValue(metric DistanceOperator, partitioningValues, argumentValues []Value, efSearch *int, isReturningVectors *bool) *DistanceRowNumberValue

func (*DistanceRowNumberValue) Evaluate(evalCtx any) (any, error)

func (*DistanceRowNumberValue) IsIndexOnly() bool

func (v *DistanceRowNumberValue) Name() string

euclidean_distance_row_number
euclidean_square_distance_row_number
cosine_distance_row_number
dot_product_distance_row_number

func (*DistanceRowNumberValue) Type() Type

func (v *DistanceRowNumberValue) WithChildren(newChildren []Value) *DistanceRowNumberValue

type DistanceValue ¶

type DistanceValue struct {
	Operator   DistanceOperator
	LeftChild  Value
	RightChild Value
}

DistanceValue computes a distance metric between two vector expressions. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.DistanceValue`.

SQL surface:

WHERE euclidean_distance(embedding, queryVec) < 0.5
ORDER BY cosine_distance(vec_field, target) ASC LIMIT 10

Used in similarity-search + nearest-neighbor queries — typically paired with HNSW vector indexes via the K-NN query rewrite that transforms `ROW_NUMBER() OVER (ORDER BY distance(...)) <= K` into a DistanceRankValueComparison + index-backed scan. The distance computation itself is a scalar Value evaluated per-row.

Result type: NotNullDouble. All distance metrics produce a non-NULL real number when both operands are non-NULL vectors.

Eval contract:

• LeftChild + RightChild evaluate to []float64 (vector representation in Go; Java uses RealVector).
• Mismatched-length vectors → eval returns nil (type-degraded).
• NULL vectors → Java throws RecordCoreException; Go returns nil (Go surfaces the error as nil per existing pattern; downstream rules can choose to reject earlier at planner level).

Note: eval is functional for `[]float64` operands — vector type support is gated on broader infrastructure (Type.Vector + binary vector encoding), but the metric math itself works directly on double slices for testability + plan-equivalence with Java.

func NewDistanceValue(op DistanceOperator, left, right Value) *DistanceValue

func (v *DistanceValue) Children() []Value

func (v *DistanceValue) Evaluate(evalCtx any) (any, error)

func (v *DistanceValue) Name() string

func (*DistanceValue) Type() Type

type DotProductDistanceRowNumberValue ¶

type DotProductDistanceRowNumberValue struct {
	WindowedValue
}

DotProductDistanceRowNumberValue is the dot-product-distance K-NN ROW_NUMBER() window function. Assigns unique sequential row numbers (1-based) ordered by dot product distance from a reference vector. Vectors with larger dot products (more aligned) get lower numbers.

Mirrors Java's com.apple.foundationdb.record.query.plan.cascades.values.DotProductDistanceRowNumberValue — a concrete WindowedValue + IndexOnlyValue subclass.

Dot product distance is the negative dot product: vectors with higher dot products (more similar) have smaller distances.

This value is index-only: the row number is computed during HNSW index traversal, not from base records.

Result type: NotNullLong.

func NewDotProductDistanceRowNumberValue(partitioningValues, argumentValues []Value) *DotProductDistanceRowNumberValue

func (*DotProductDistanceRowNumberValue) Evaluate(evalCtx any) (any, error)

func (*DotProductDistanceRowNumberValue) IsIndexOnly() bool

func (*DotProductDistanceRowNumberValue) Name() string

func (*DotProductDistanceRowNumberValue) Type() Type

func (v *DotProductDistanceRowNumberValue) WithChildren(newChildren []Value) *DotProductDistanceRowNumberValue

type EmptyValue ¶

type EmptyValue struct{}

EmptyValue represents an empty record (zero fields). Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.EmptyValue`.

Used by:

• Default value for COUNT(*) over an empty set (returns 0; the empty record is the unit element for COUNT).
• Insert/Update/Delete operations that don't return a row but need a Value-shaped placeholder for the planner.
• Any rewrite that produces a "no-op" Value tree.

Type is the empty RecordType (no fields, non-null).

Evaluate returns nil (no fields → nothing to evaluate).

func NewEmptyValue() *EmptyValue

func (*EmptyValue) Children() []Value

func (*EmptyValue) Evaluate(any) (any, error)

func (*EmptyValue) Name() string

func (*EmptyValue) Type() Type

type EnumType ¶

type EnumType struct {
	// EnumName is the enum's type identifier — empty string for
	// anonymous enums (rare in real schemas but legal).
	EnumName string
	// Nullable reports whether the enum column allows NULL.
	Nullable bool
	// Values are the declared enum members in declared order.
	Values []EnumValue
}

EnumType is the Type impl for SQL ENUM columns. Mirrors Java's Enum nested type. Carries an EnumName (the enum's type identifier) plus an ordered list of EnumValues.

Two EnumType instances are Equal iff their EnumName + Nullable match AND their Values slice is element-wise equal.

func NewEnumType(name string, nullable bool, values []EnumValue) *EnumType

func (*EnumType) Code() TypeCode

func (e *EnumType) Equals(other Type) bool

func (e *EnumType) IsNullable() bool

func (e *EnumType) LookupValueByName(name string) (EnumValue, bool)

func (e *EnumType) LookupValueByNumber(number int32) (EnumValue, bool)

func (e *EnumType) String() string

type EnumValue ¶

type EnumValue struct {
	// Name is the enum member's identifier.
	Name string
	// Number is the declared ordinal (matches protobuf semantics —
	// stable across schema evolution; renames are forbidden but
	// repurposing a number is a hard breaking change).
	Number int32
}

EnumValue is one member of an EnumType. Mirrors Java's Enum.EnumValue — a Name + Number pair where the Number is the declared ordinal (matches the protobuf enum-value semantics).

func (e EnumValue) Equals(other EnumValue) bool

type EuclideanDistanceRowNumberValue ¶

type EuclideanDistanceRowNumberValue struct {
	WindowedValue
}

EuclideanDistanceRowNumberValue is the Euclidean-distance K-NN ROW_NUMBER() window function. Assigns unique sequential row numbers (1-based) ordered by Euclidean distance from a reference vector. Closer vectors receive lower numbers.

Mirrors Java's com.apple.foundationdb.record.query.plan.cascades.values.EuclideanDistanceRowNumberValue — a concrete WindowedValue + IndexOnlyValue subclass.

Euclidean distance is sqrt(sum((a_i - b_i)^2)) — the standard L2 distance.

This value is index-only: the row number is computed during HNSW index traversal, not from base records.

Result type: NotNullLong.

func NewEuclideanDistanceRowNumberValue(partitioningValues, argumentValues []Value) *EuclideanDistanceRowNumberValue

func (*EuclideanDistanceRowNumberValue) Evaluate(evalCtx any) (any, error)

func (*EuclideanDistanceRowNumberValue) IsIndexOnly() bool

func (*EuclideanDistanceRowNumberValue) Name() string

func (*EuclideanDistanceRowNumberValue) Type() Type

func (v *EuclideanDistanceRowNumberValue) WithChildren(newChildren []Value) *EuclideanDistanceRowNumberValue

type EuclideanSquareDistanceRowNumberValue ¶

type EuclideanSquareDistanceRowNumberValue struct {
	WindowedValue
}

EuclideanSquareDistanceRowNumberValue is the squared-Euclidean- distance K-NN ROW_NUMBER() window function. Assigns unique sequential row numbers (1-based) ordered by squared Euclidean distance from a reference vector. Closer vectors receive lower numbers.

Mirrors Java's com.apple.foundationdb.record.query.plan.cascades.values.EuclideanSquareDistanceRowNumberValue — a concrete WindowedValue + IndexOnlyValue subclass.

Squared Euclidean distance is sum((a_i - b_i)^2) — same ordering as L2 without the sqrt cost, making it computationally cheaper for nearest-neighbor searches where only relative ordering matters.

This value is index-only: the row number is computed during HNSW index traversal, not from base records.

Result type: NotNullLong.

func NewEuclideanSquareDistanceRowNumberValue(partitioningValues, argumentValues []Value) *EuclideanSquareDistanceRowNumberValue

func (*EuclideanSquareDistanceRowNumberValue) Evaluate(evalCtx any) (any, error)

func (*EuclideanSquareDistanceRowNumberValue) IsIndexOnly() bool

func (*EuclideanSquareDistanceRowNumberValue) Name() string

func (*EuclideanSquareDistanceRowNumberValue) Type() Type

func (v *EuclideanSquareDistanceRowNumberValue) WithChildren(newChildren []Value) *EuclideanSquareDistanceRowNumberValue

type EvaluatesTo ¶

type EvaluatesTo int

EvaluatesTo discriminates the four supported evaluations.

const (
	// EvaluatesToTrue is `x IS TRUE`.
	EvaluatesToTrue EvaluatesTo = iota
	// EvaluatesToFalse is `x IS FALSE`.
	EvaluatesToFalse
	// EvaluatesToNull is `x IS NULL`.
	EvaluatesToNull
	// EvaluatesToNotNull is `x IS NOT NULL`.
	EvaluatesToNotNull
)

type EvaluatesToValue ¶

type EvaluatesToValue struct {
	Child Value
	Eval  EvaluatesTo
}

EvaluatesToValue tests whether a child Value's runtime evaluation matches one of four boolean-shaped predicates: IS TRUE, IS FALSE, IS NULL, IS NOT NULL. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values. EvaluatesToValue`.

x IS TRUE    ↔  EvaluatesToValue{Child: x, Eval: EvaluatesToTrue}
x IS NULL    ↔  EvaluatesToValue{Child: x, Eval: EvaluatesToNull}

Used by:

• SQL `IS [NOT] {NULL,TRUE,FALSE}` predicates lowered to the Value layer.
• Plan rewrites that need to pattern-match on these specific truth-value shapes.

Type is always non-null boolean (these predicates have a defined result for any operand — even NULL maps to TRUE/FALSE).

func NewEvaluatesToValue(child Value, eval EvaluatesTo) *EvaluatesToValue

func (v *EvaluatesToValue) Children() []Value

func (v *EvaluatesToValue) Evaluate(evalCtx any) (any, error)

func (*EvaluatesToValue) Name() string

func (*EvaluatesToValue) Type() Type

type ExistsValue ¶

type ExistsValue struct {
	// Value is the child Value — a *QuantifiedObjectValue over the
	// existential quantifier's object. The correlation is carried by
	// this child, NOT by ExistsValue itself.
	Value Value
}

ExistsValue is the Value-layer SQL `EXISTS` operator: yields TRUE if a subquery's row stream is non-empty. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.ExistsValue` (4.12 `c9274172c`), which refactored it from a non-evaluable leaf quantifier wrapper into a proper EVALUABLE ValueWithChild.

EXISTS (SELECT ... FROM t WHERE ...)
  ↔  ExistsValue{Value: QuantifiedObjectValue{Correlation: αsubq}}

The child is a *QuantifiedObjectValue over the subquery's existential quantifier. EXISTS is true iff that quantifier's object (the current row of the subplan) is non-null — i.e. the subplan yielded at least one row (Java's `getChild().eval() != null`).

There is ONE EXISTS representation (RFC-141): WHERE-EXISTS is this value funnelled through ToQueryPredicate() → ExistentialValuePredicate; a projected EXISTS uses the value directly as a column. The standalone alias-leaf ExistsPredicate was deleted.

Type is non-null boolean (EXISTS always has a definite truth value — even on empty subqueries it returns FALSE).

func NewExistsValue(alias CorrelationIdentifier) *ExistsValue

func NewExistsValueWithChild(v Value) *ExistsValue

func (v *ExistsValue) Children() []Value

func (v *ExistsValue) Evaluate(ctx any) (any, error)

func (v *ExistsValue) GetChild() Value

func (v *ExistsValue) GetCorrelatedTo() map[CorrelationIdentifier]struct{}

func (*ExistsValue) Name() string

func (*ExistsValue) Type() Type

func (v *ExistsValue) WithNewChild(c Value) *ExistsValue

type ExpressionFolder ¶

type ExpressionFolder interface {
	Fold(v Value) (any, bool)
}

ExpressionFolder is the testable surface for plan-time constant folding of standalone Values. Implementations: DefaultFolder (production — composes SimplifyValue with EvaluateConstant), and any caller-provided test fake that returns canned answers without invoking real simplification.

Why an interface, not a free function: callers like `embedded.foldConstantProjections` need to be unit-testable without constructing a real catalog + Resolver + metadata. With an injected folder, the routing logic ("did we already fold this slot? is the slice big enough?") can be exercised against a fake folder that returns whatever the test wants. Per RFC-025 §"Closing the leaks".

Contract: Fold returns (foldedValue, true) when v is a row-context- independent Value whose evaluation produces a Go-native scalar that LiteralValue can faithfully re-wrap. Returns (nil, false) on a non-foldable input — a FieldValue, a ParameterValue, an AggregateValue, or any composite containing those. Nil v returns (nil, false) — the boundary so callers don't need to nil-guard.

func DefaultFolder() ExpressionFolder

type Field ¶

type Field struct {
	// Name is the field's identifier. Empty string is legal and
	// represents an anonymous field — `RECORD<INT, STRING>` produces
	// fields with Name="" but distinct Ordinals.
	Name string
	// FieldType is the field's type. Never nil — anonymous /
	// untyped fields use UnknownType.
	FieldType Type
	// Ordinal is the field's position in the record (0-based). It is the
	// Java *ordinal* (Type.Record.computeFieldNameToOrdinal = list position),
	// NOT the protobuf fieldIndex/tag. NewRecordType normalizes Ordinal to the
	// slice position, so Fields[i].Ordinal == i; ordinal resolution reads the
	// slice position directly (RecordType.FieldIndex) for soundness even on a
	// raw RecordType. Anonymous fields share Name="" but have distinct Ordinals.
	Ordinal int
}

Field is one field of a RecordType. Mirrors Java's Record.Field — name + type + ordinal. The Ordinal carries the declared position for stable ordering across maps; two Fields with the same Name but different Ordinals are NOT equal.

func (f Field) Equals(other Field) bool

type FieldPath ¶

type FieldPath struct {
	Accessors []ResolvedAccessor

	// FrontierPinned carries the S2 gated-join FRONTIER CONTRACT: the node was
	// baked at a gated-join seed whose executor births positional rows, so a
	// name-keyed read is a planner/executor bug (loud *BakedNameContextError,
	// bakedNameReadGuard). Unpinned baked nodes (the recursive-CTE wrap) have
	// no such guarantee and keep the quiet name-model read off the positional
	// frontier. The contract is a property of the VALUE, invariant under
	// transformation — pullup/pushdown passthrough copies strip Child but
	// share this pointer, so keying the guard on child presence would let a
	// semantics-preserving rewrite silently demote a loud node (unification
	// review ruling). Lives ON THE PATH, once, not per-accessor: the contract
	// governs the ROOT read context; accessors beyond the first read nested
	// records, where the bit is meaningless (S3 staging ruling — N copies of
	// a one-meaning bit desynchronize). EXCLUDED from identity/hash/Explain:
	// an evaluation-contract marker, not a value distinction. Dies in Slice 4
	// with the guard and the name model.
	FrontierPinned bool
}

FieldPath is the RFC-173 S3 multi-accessor path — Java's FieldValue.FieldPath (FieldValue.java:373): ONE FieldValue node holds a whole path, never chained nodes. IMMUTABLE after construction (replace-never-mutate, the S2 accessor convention carried over): FieldValue copy sites share the pointer; WithSuffix returns a NEW path (Java :525-534). In the S2-compatible window every production path is single-accessor (the gated-join seed and the recursive-CTE wrap); multi-accessor paths are produced only by the baked-gated compose rule until the S3-W2/W3 flip widens it. INVARIANT: a FieldPath carried by a FieldValue is NON-EMPTY — a zero-step path reads nothing and is not a meaningful accessor (Java's FieldPath.EMPTY exists only for prefix arithmetic Go doesn't port in W1). Both constructors (NewFieldPathOfSingle, WithSuffix) uphold it; Root()/Last() panic on a hand-built violation rather than tolerating it.

func NewFieldPathOfSingle(field string, ordinal int, frontierPinned bool) *FieldPath

func (p *FieldPath) Equals(o *FieldPath) bool

func (p *FieldPath) Last() ResolvedAccessor

func (p *FieldPath) Root() ResolvedAccessor

func (p *FieldPath) Single() (ResolvedAccessor, bool)

func (p *FieldPath) WithSuffix(suffix *FieldPath) *FieldPath

type FieldValue ¶

type FieldValue struct {
	Field string
	Typ   Type
	Child Value // base value (nil = legacy flat field reference)

	// Resolved is the RFC-173 baked-ordinal marker — Java's construction-time
	// FieldPath resolution, where the accessor IS an ordinal and runtime access
	// is positional. nil = LAZY node (today's model: the column position is
	// re-derived from the child's flowed type on every resolveOrdinal). Non-nil
	// = BAKED node: resolveOrdinal returns the accessor's ordinal directly, so
	// a positional-row read is row.Get(ordinal) — position-preserving by
	// construction, and therefore sound under DUPLICATE output names, which
	// every name-based resolution collapses (RecordType.FieldIndex is
	// first-match; the name-keyed Datum is last-wins). Field is then a DISPLAY
	// name for diagnostics and name-model coexistence.
	//
	// Two construction shapes during the coexistence window:
	//   - NewFieldValueOfOrdinal (gated-join seeds): child-bearing over a typed
	//     leg QOV, FrontierPinned — the executor guarantees positional rows, so
	//     a name-keyed read is a loud *BakedNameContextError.
	//   - NewFieldValueWithResolvedOrdinal (recursive-CTE leg wrap): childless,
	//     unpinned — no frontier guarantee; off the positional frontier Field
	//     names the Datum read key, so one Value works under both row models.
	// Both are SINGLE-accessor paths; multi-accessor paths exist only via the
	// baked-gated compose rule (S3-W1, dark) until the S3-W2/W3 flip.
	//
	// Identity refinement (contract, RFC-173 §4 Slice 2 ruling #2, widened
	// element-wise by the S3 staging ruling): BAKED nodes compare by
	// per-element (Field, Ordinal) list equality (FieldPath.Equals); baked vs
	// lazy is UNEQUAL (worst case a missed dedup, never a conflation); lazy vs
	// lazy stays name-only. FrontierPinned is EXCLUDED from
	// identity/hash/Explain (an evaluation-contract marker, not a value
	// distinction — like Java excluding name/type from ResolvedAccessor
	// equality). Every FieldValue copy/rebuild site MUST preserve this marker —
	// dropping it silently degrades a baked node to lazy, which conflates
	// duplicate same-named columns at different ordinals (§5 duplicate-name
	// pin). For baked nodes Field equals the LAST accessor's name (Java
	// getLastFieldName) — display and name-model coexistence only.
	Resolved *FieldPath
}

FieldValue references a column by name on a base value. In the full Java model, FieldValue always has a child value (typically a QuantifiedObjectValue correlated to a quantifier) and a FieldPath (multi-step for nested access). In Go, Child is optional for backward compatibility: nil Child = leaf field reference (flat model used by existing code).

With Child set, FieldValue participates in correlation tracking: GetCorrelatedToOfValue walks into Children() and discovers the child's correlation. This is essential for push-through rules that need to know whether a value is correlated to a specific quantifier.

Field-name contract: callers constructing FieldValue via the SQL resolver (expr.ResolveIdentifier) receive the case-folded (upper- case) form, matching Identifier.Name(). Downstream row producers MUST normalise their map keys to the same form.

func NewFieldValue(child Value, field string, typ Type) *FieldValue

func NewFieldValueOfOrdinal(child Value, ordinal int) (*FieldValue, error)

func NewFieldValueWithResolvedOrdinal(field string, ordinal int, typ Type) *FieldValue

func NewFlatFieldValue(field string, typ Type) *FieldValue

func NewOrdinalFieldValue(child Value, ordinal int, typ Type) *FieldValue

func (f *FieldValue) Children() []Value

func (f *FieldValue) Evaluate(evalCtx any) (any, error)

func (f *FieldValue) Name() string

func (f *FieldValue) Type() Type

type FirstOrDefaultStreamingValue ¶

type FirstOrDefaultStreamingValue struct {
	ChildValue         Value
	OnEmptyResultValue Value
}

FirstOrDefaultStreamingValue is the streaming variant of FirstOrDefaultValue. Returns the first element produced by its streaming child Value, or the default Value if the stream is empty. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.FirstOrDefaultStreamingValue`.

The child should implement StreamingValue. RangeValue returns []int64 (not []any), so it doesn't satisfy StreamingValue and is handled by an explicit type-switch fallback in Evaluate.

func NewFirstOrDefaultStreamingValue(childValue, onEmpty Value) *FirstOrDefaultStreamingValue

func (v *FirstOrDefaultStreamingValue) Children() []Value

func (v *FirstOrDefaultStreamingValue) Evaluate(evalCtx any) (any, error)

func (*FirstOrDefaultStreamingValue) Name() string

func (v *FirstOrDefaultStreamingValue) Type() Type

func (v *FirstOrDefaultStreamingValue) WithChildren(newChildren []Value) *FirstOrDefaultStreamingValue

type FirstOrDefaultValue ¶

type FirstOrDefaultValue struct {
	Array   Value
	Default Value
	// Typ is the result type — Java's constructor sets it to the
	// array element type. Defaults to UnknownType.
	Typ Type
}

FirstOrDefaultValue returns the first element of an array, OR a default value if the array is empty / NULL. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values. FirstOrDefaultValue`.

FIRST_OR_DEFAULT(arr, default)
  ↔  FirstOrDefaultValue{Array: arr, Default: default}

Used by the planner for materializing scalar subquery results where the subquery may return zero rows.

CONFORMANCE: matches Java's eval semantics:

• NULL array → NULL (the default isn't returned for NULL).
• Empty array → Default's evaluated value.
• Non-empty array → first element.

Type is the array's element type (Java's constructor enforces the array.elementType == default.type invariant; Go accepts whatever type the caller provides).

func NewFirstOrDefaultValue(array, defaultVal Value, resultType Type) *FirstOrDefaultValue

func (v *FirstOrDefaultValue) Children() []Value

func (v *FirstOrDefaultValue) Evaluate(evalCtx any) (any, error)

func (*FirstOrDefaultValue) Name() string

func (v *FirstOrDefaultValue) Type() Type

type FromOrderedBytesValue ¶

type FromOrderedBytesValue struct {
	Child      Value
	Direction  OrderedBytesDirection
	TargetType Type
}

FromOrderedBytesValue decodes an ordered-bytes blob (the output of ToOrderedBytesValue) back to the original typed value. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.FromOrderedBytesValue`.

The decoder needs the encoded direction (so it knows whether to undo the DESC inversion) and the target type (so it knows what Tuple element type to extract). Java's class carries both fields.

As the inverse of ToOrderedBytesValue, this Value typically appears in covering-index / index-only access plans where the planner has rewritten a SQL projection to read the encoded form from an index entry.

func NewFromOrderedBytesValue(child Value, direction OrderedBytesDirection, targetType Type) *FromOrderedBytesValue

func (v *FromOrderedBytesValue) Children() []Value

func (*FromOrderedBytesValue) Evaluate(any) (any, error)

func (*FromOrderedBytesValue) Name() string

func (v *FromOrderedBytesValue) Type() Type

type InOpValue ¶

type InOpValue struct {
	Probe Value
	List  Value // expected to evaluate to []any at runtime
}

InOpValue is the Value-layer SQL `IN` operator: tests whether a probe value matches any element of a list of candidate values. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades. values.InOpValue`.

probe IN (a, b, c)  ↔  InOpValue{Probe: probe, List: [a, b, c]}

Why a Value-layer IN in addition to the predicate-layer `ComparisonPredicate{Type: ComparisonIn}`: rules that operate at the Value tree (e.g. fold a constant probe against a constant list) need a Value-shaped node. The predicate-side path is reserved for evaluation; the Value-side path is for plan rewrites.

Java's InOpValue carries an `inListValue` Value (typically LiteralValue wrapping a list, or a ListValue node), making it possible to express IN against dynamic lists. Go accepts a generic List Value field that can be a literal []any (for static IN-lists) or any other Value that evaluates to a slice at runtime.

Evaluate semantics — Kleene 3VL:

• probe IN (NULL, ...) where probe is non-NULL: TRUE if any non-NULL element matches, otherwise UNKNOWN (NULL propagation).
• NULL IN (anything): UNKNOWN.
• Empty list: FALSE (no match possible).

Type is always nullable boolean — IN can produce NULL via Kleene propagation.

func NewInOpValue(probe, list Value) *InOpValue

func (v *InOpValue) Children() []Value

func (v *InOpValue) Evaluate(evalCtx any) (any, error)

func (*InOpValue) Name() string

func (*InOpValue) Type() Type

type IncarnationValue ¶

type IncarnationValue struct{}

IncarnationValue is a LEAF Value that returns the record store's incarnation number — an integer counter the store advances whenever its versionstamp prefix is "fresh" (e.g. after a tenant move / re-key). Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.IncarnationValue`.

SQL-callable as `get_versionstamp_incarnation()`. The underlying purpose is to let queries detect store-incarnation changes when processing versionstamp-keyed data — two versionstamps from different incarnations are not directly comparable, so a query that joins / dedups across versionstamp boundaries uses this to scope correctness.

Result type: INT (NOT NULL — every store has an incarnation).

Per Java's contract, eval requires a non-null FDBRecordStoreBase; Go accepts an evalCtx that exposes an "incarnation" key (the row-shape harness pattern shared with VersionValue), and otherwise returns nil. FDBRecordStore.GetIncarnation() exists on the store side, but no execution path threads a store into this Value's Evaluate — it is parser / planner / fuzz-reachable without a store-bound runtime evaluator, matching the non-evaluable placeholder pattern of ObjectValue / QueriedValue / CardinalityValue.

func NewIncarnationValue() *IncarnationValue

func (*IncarnationValue) Children() []Value

func (*IncarnationValue) Evaluate(evalCtx any) (any, error)

func (*IncarnationValue) Name() string

func (*IncarnationValue) Type() Type

type IndexEntryObjectValue ¶

type IndexEntryObjectValue struct {
	IndexEntryAlias CorrelationIdentifier
	Source          TupleSource
	OrdinalPath     []int
	ResultType      Type
}

IndexEntryObjectValue is a LEAF Value that references a specific position inside an IndexEntry's KEY or VALUE tuple, identified by an ordinal path (the Java-side "Dewey id"). Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.IndexEntryObjectValue`.

Used by covering-index plans + index-only access paths: when a query can be answered directly from the index entry's key/value tuples (without fetching the underlying record), this Value extracts a specific column from those tuples by ordinal walk.

Conceptually:

IndexEntryObjectValue(alias, KEY,   [0])    — first KEY column
IndexEntryObjectValue(alias, KEY,   [2])    — third KEY column
IndexEntryObjectValue(alias, VALUE, [0, 1]) — second sub-field
                                              of first VALUE column

The alias identifies WHICH index-entry binding to read in the EvaluationContext (a query may join several indexed scans, each flowing its own IndexEntry).

Constraints (matches Java's Verify.verify in the constructor):

• resultType must be primitive, enum, or UUID — IndexEntry tuples can only hold leaf-type Tuple-encodable values; structs are extracted via separate FieldValue chains, not through ordinal paths.
• Go enforces this via planner-checked precondition rather than a runtime panic — Java's Verify would crash; we surface as a no-op-ready Value that evaluates to nil if the type contract is violated.

Eval contract:

• evalCtx must be a `map[CorrelationIdentifier]any` shape with a binding for `IndexEntryAlias`. The bound value is expected to expose `PrimaryKey() / IndexValues()` (the `*recordlayer.IndexEntry` shape) — typed as `IndexEntryReader` here to keep the values package free of the recordlayer dependency.
• On lookup miss, returns nil (matches the "non-evaluable yet" pattern of placeholder Values like ObjectValue / VersionValue).

func NewIndexEntryObjectValue(alias CorrelationIdentifier, source TupleSource, ordinalPath []int, resultType Type) *IndexEntryObjectValue

func (*IndexEntryObjectValue) Children() []Value

func (v *IndexEntryObjectValue) Evaluate(evalCtx any) (any, error)

func (*IndexEntryObjectValue) GetCorrelatedTo() map[CorrelationIdentifier]struct{}

func (*IndexEntryObjectValue) Name() string

func (v *IndexEntryObjectValue) Type() Type

type IndexEntryReader ¶

type IndexEntryReader interface {
	// PrimaryKey returns the KEY tuple of the index entry — the
	// indexed-column tuple plus the trailing primary-key columns.
	PrimaryKey() any
	// IndexValues returns the VALUE tuple of the index entry — the
	// payload tuple (typically empty for VALUE indexes; populated
	// for KeyWithValue covering-index entries).
	IndexValues() any
}

IndexEntryReader is the minimal interface IndexEntryObjectValue needs to walk an FDB index entry. The Go *recordlayer.IndexEntry type satisfies this contract via its PrimaryKey + IndexValues methods. Defined here (rather than imported from recordlayer) to keep the cycle-free dependency direction values → ø.

type IndexOnly ¶

type IndexOnly interface {
	Value
	IsIndexOnly() bool
}

IndexOnly is the Go-side counterpart to Java's `Value.IndexOnlyValue` interface marker. Any Value whose result can ONLY be produced by an index scan (vs a streaming aggregator over the base records) implements this marker.

Used by: RowNumberValue, DistanceRowNumberValue, IndexOnlyAggregateValue.

Planner / matcher code can type-assert against this to refuse to optimise paths that would require running the value over a base- record scan — they MUST be matched against an index, otherwise the plan fails to compile.

type IndexOnlyAggregateOp ¶

type IndexOnlyAggregateOp int

IndexOnlyAggregateOp enumerates the index-only aggregate operators — aggregations that MUST be backed by an aggregate index because they can't be evaluated by a streaming aggregator at runtime. Mirrors Java's `IndexOnlyAggregateValue.PhysicalOperator` (MAX_EVER_LONG / MIN_EVER_LONG).

const (
	// IndexOnlyMaxEverLong is the running-max-since-time-zero
	// aggregate, backed by FDB's MAX_EVER_LONG index. Returns the
	// largest value ever seen across all writes to the indexed
	// column — even if the row has since been deleted.
	IndexOnlyMaxEverLong IndexOnlyAggregateOp = iota
	// IndexOnlyMinEverLong is the corresponding MIN_EVER aggregate.
	IndexOnlyMinEverLong
)

func (op IndexOnlyAggregateOp) String() string

type IndexOnlyAggregateValue ¶

type IndexOnlyAggregateValue struct {
	Op    IndexOnlyAggregateOp
	Child Value
}

IndexOnlyAggregateValue represents a compile-time aggregation that MUST be backed by an aggregate index — it cannot be evaluated by a streaming aggregator at runtime. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.IndexOnlyAggregateValue`.

Java has two abstract subclasses (MaxEverValue, MinEverValue) per operator. The Go port unifies via an Op field — same matchability pattern as DistanceRowNumberValue.

At plan time, the planner must match this Value against an aggregate index of the corresponding type (MAX_EVER_LONG / MIN_EVER_LONG). If no matching index exists, the plan fails to compile — Java throws SemanticException; Go would surface the failure at the rule level (IsIndexOnly() returns true so the planner knows to refuse to optimise without an index).

Eval is a placeholder — IndexOnlyAggregateValue is non-evaluable by definition (Java's eval throws IllegalStateException; Go's surface returns nil per the existing pattern).

Implements the IndexableAggregate interface — GetIndexTypeName returns the operator name for index lookup.

func NewIndexOnlyAggregateValue(op IndexOnlyAggregateOp, child Value) *IndexOnlyAggregateValue

func (v *IndexOnlyAggregateValue) Children() []Value

func (*IndexOnlyAggregateValue) Evaluate(any) (any, error)

func (v *IndexOnlyAggregateValue) GetIndexTypeName() string

func (*IndexOnlyAggregateValue) IsIndexOnly() bool

func (*IndexOnlyAggregateValue) IsNonEvaluable() bool

func (v *IndexOnlyAggregateValue) Name() string

func (v *IndexOnlyAggregateValue) Type() Type

func (v *IndexOnlyAggregateValue) WithChildren(newChildren []Value) *IndexOnlyAggregateValue

type IndexableAggregate ¶

type IndexableAggregate interface {
	Value
	GetIndexTypeName() string
}

IndexableAggregate is the Go-side counterpart to Java's IndexableAggregateValue interface. Any Value that has an index- backed aggregate form can implement this — currently only AggregateValue (when its Op has a non-empty index-type name).

Planner / matcher code can type-assert against this interface to pick aggregates eligible for index-scan lowering:

if iav, ok := v.(IndexableAggregate); ok && iav.GetIndexTypeName() != "" {
    // can lower to index-aggregate scan
}

type IndexedValue ¶

type IndexedValue struct {
	ResultType Type
}

IndexedValue is a leaf placeholder representing a column value bound to an indexed-key position. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.IndexedValue`.

Used by index-pushdown rules during pattern matching: a logical FieldValue can be matched against an IndexedValue placeholder to verify that the predicate's column corresponds to an indexed position in the candidate index.

IndexedValue is a "non-evaluable" Value — it represents a position in an index key, not a computed result. Calling Evaluate panics so misuse surfaces loudly.

func NewIndexedValue(resultType Type) *IndexedValue

func (*IndexedValue) Children() []Value

func (*IndexedValue) Evaluate(any) (any, error)

func (*IndexedValue) Name() string

func (v *IndexedValue) Type() Type

type InvalidArgumentError ¶

type InvalidArgumentError struct {
	Message string
}

InvalidArgumentError is returned by a scalar function when an argument is outside the function's mathematical domain — currently SQRT of a negative number. The executor converts this to SQLSTATE 22023 INVALID_PARAMETER_VALUE. Distinct from ScalarTypeMismatchError (wrong argument *type*); this is a wrong argument *value* of the right type.

func (e *InvalidArgumentError) Error() string

type InvalidCastError ¶

type InvalidCastError struct {
	Message string
}

InvalidCastError is returned by CastValue.Evaluate when a cast is out of range or structurally invalid (NaN→INT, overflow, etc.). The executor converts this to SQLSTATE 22F3H INVALID_CAST.

func (e *InvalidCastError) Error() string

type LeafValue ¶

type LeafValue interface {
	Value

	// RebaseLeaf returns a new Value that is the same as this one but
	// with correlated identifiers updated to targetAlias. Returns this
	// if there are no correlated identifiers to update.
	//
	// Ports Java's LeafValue.rebaseLeaf(CorrelationIdentifier).
	RebaseLeaf(targetAlias CorrelationIdentifier) Value
}

LeafValue is the Go counterpart of Java's LeafValue interface — a scalar value type that has no children. LeafValues participate in translation/rebasing via RebaseLeaf, which returns a new Value with correlation identifiers updated to a target alias.

Ports Java's com.apple.foundationdb.record.query.plan.cascades.values.LeafValue.

type LikeOperatorValue ¶

type LikeOperatorValue struct {
	Probe   Value
	Pattern Value
}

LikeOperatorValue is the Value-layer SQL `LIKE` operator: tests whether a string value matches a SQL LIKE pattern. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values. LikeOperatorValue`.

probe LIKE 'abc%'  ↔  LikeOperatorValue{Probe: probe, Pattern: 'abc%'}

Why a Value-layer LIKE in addition to the predicate-layer ComparisonLike: rules that operate on the Value tree (e.g. fold a constant probe against a constant pattern, or extract a prefix for index-pushdown) need a Value-shaped node.

SQL LIKE wildcards:

• `%` matches zero or more characters
• `_` matches exactly one character
• other characters match literally

Delegates to the canonical LikeMatch helper (shared with the QueryPredicate-layer ComparisonLike). The matcher is pinned by FuzzLikeMatch / FuzzLikeMatchEscape against a regex oracle and matches Java's `Comparisons.likeMatcher` semantics.

Note: this Value-level LIKE carries no ESCAPE (escape rune = 0). ESCAPE support lives on the predicate layer (Comparison.Escape, predicates/comparisons.go) and in the shared LikeMatch helper — add the field here only if a Value-level ESCAPE consumer appears.

Evaluate semantics — Kleene 3VL:

• non-NULL probe + non-NULL pattern: true if pattern matches, false otherwise.
• NULL probe OR NULL pattern: nil (UNKNOWN).
• Non-string probe: nil (type-degraded).

Type is always nullable boolean.

func NewLikeOperatorValue(probe, pattern Value) *LikeOperatorValue

func (v *LikeOperatorValue) Children() []Value

func (v *LikeOperatorValue) Evaluate(evalCtx any) (any, error)

func (*LikeOperatorValue) Name() string

func (*LikeOperatorValue) Type() Type

type NonEvaluable ¶

type NonEvaluable interface {
	Value
	IsNonEvaluable() bool
}

NonEvaluable is the Go-side counterpart to Java's `Value.NonEvaluableValue` interface marker. Any Value that can't be evaluated at runtime (plan-time-only placeholders like AggregateValue, IndexOnlyAggregateValue) implements this marker.

Planner / matcher code can type-assert against this to refuse to pass non-evaluable Values to runtime evaluators.

Java's NonEvaluableValue is a true marker interface (no methods); the Go equivalent uses one method whose presence (and the implied `true` return) IS the marker.

type NotValue ¶

type NotValue struct {
	Child Value
}

NotValue is the Value-layer NOT — the boolean negation of a single child Value. Mirrors Java's `com.apple.foundationdb.record.query. plan.cascades.values.NotValue`.

Why a Value-layer NOT in addition to the predicate-layer NotPredicate: boolean negation appears in non-predicate contexts too — e.g. `SELECT NOT(active) FROM t` where the result column carries a nullable boolean, not a 3VL truth value the predicate system can route. Cascades rules that float between Value and QueryPredicate representations need a Value-shaped NOT so the rebuild stays a Value tree. Java's NotValue.toQueryPredicate() bridges back to NotPredicate when the surrounding context calls for it; Go keeps the layers separate — the only value→predicate bridge is the EXISTS one (predicates/existential_value_predicate.go).

Evaluate semantics — Kleene 3VL:

• NOT TRUE = FALSE
• NOT FALSE = TRUE
• NOT NULL = NULL (NULL propagates)
• NOT non-bool = nil (UNKNOWN — degraded type mismatch)

Type is always TypeBool (NOT is a boolean operator).

func NewNotValue(child Value) *NotValue

func (n *NotValue) Children() []Value

func (n *NotValue) Evaluate(evalCtx any) (any, error)

func (*NotValue) Name() string

func (n *NotValue) Type() Type

type NullValue ¶

type NullValue struct {
	Typ Type // type NULL was cast to; UnknownType when unconstrained
}

NullValue is the SQL NULL literal — evaluates to nil regardless of context. Not collapsed into ConstantValue{Value: nil} because having a dedicated type lets rule matchers check for NULL specifically (without also matching `Value: nil` ConstantValues that happen to represent a NULL literal in a non-type-annotated way).

func NewNullValue(typ Type) *NullValue

func (*NullValue) Children() []Value

func (*NullValue) Evaluate(any) (any, error)

func (*NullValue) Name() string

func (n *NullValue) Type() Type

type ObjectValue ¶

type ObjectValue struct {
	Alias      CorrelationIdentifier
	ResultType Type
}

ObjectValue is a generic typed-object placeholder bound to a CorrelationIdentifier. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.ObjectValue`.

Used by Java to represent "any object" in expression contexts — generic counterpart to QuantifiedObjectValue (which specifically represents a Quantifier's flowed object). ObjectValue is more general: used in non-quantifier contexts where the planner needs a typed placeholder bound to a specific alias.

Type is whatever the planner determined at capture time.

Non-evaluable: ObjectValue is a placeholder; specialized evaluation paths (quantifier dereferencing, etc.) handle it before reaching the per-row Eval contract. Evaluate returns nil to make the no-row-eval contract explicit.

func NewObjectValue(alias CorrelationIdentifier, resultType Type) *ObjectValue

func (*ObjectValue) Children() []Value

func (*ObjectValue) Evaluate(any) (any, error)

func (v *ObjectValue) GetCorrelatedTo() map[CorrelationIdentifier]struct{}

func (*ObjectValue) Name() string

func (v *ObjectValue) Type() Type

type OfTypeValue ¶

type OfTypeValue struct {
	Child        Value
	ExpectedType Type
}

OfTypeValue is a runtime type guard: tests whether a child Value's runtime evaluation matches an expected Type. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.OfTypeValue`.

OfTypeValue{Child: x, ExpectedType: int}  ↔  "is x a runtime int?"

Used by:

• Type-aware rule rewrites that want to gate transformations on a runtime-type assertion (e.g. an arithmetic rule that only fires when both operands are numeric at evaluation time).
• The planner's PartialMatch infrastructure (Java) — type guards factor into match-candidate compatibility checks.

Evaluate semantics:

• Returns true if the child's evaluated value matches ExpectedType.
• Returns nil (UNKNOWN) if the child evaluates to nil — NULL is compatible with any nullable type but Go conservatively reports UNKNOWN; extend the rule if nullable / non-nullable semantics ever matter to a consumer.
• Returns false otherwise.

Type is always nullable boolean (Kleene-3VL guarded).

The implementation is a Type-code match (TypeCodeBoolean == TypeCodeBoolean). It deliberately does NOT walk RecordType / ArrayType structurally — no consumer compares structured types here; extend the match if one appears.

func NewOfTypeValue(child Value, expectedType Type) *OfTypeValue

func (v *OfTypeValue) Children() []Value

func (v *OfTypeValue) Evaluate(evalCtx any) (any, error)

func (*OfTypeValue) Name() string

func (*OfTypeValue) Type() Type

type OrderedBytesDirection ¶

type OrderedBytesDirection int

OrderedBytesDirection enumerates the four ordering modes Java's `TupleOrdering.Direction` supports — combinations of (ASC|DESC) × (NULLS_FIRST|NULLS_LAST). Mirrors Java's enum verbatim so plan hashes / explain output diff cleanly across language boundaries.

const (
	// OrderedBytesAscNullsFirst sorts ascending; NULL sorts BEFORE
	// any non-null value (lowest).
	OrderedBytesAscNullsFirst OrderedBytesDirection = iota
	// OrderedBytesAscNullsLast sorts ascending; NULL sorts AFTER any
	// non-null value (highest).
	OrderedBytesAscNullsLast
	// OrderedBytesDescNullsFirst sorts descending; NULL sorts BEFORE
	// (which becomes "highest" under DESC, since the iteration is
	// reversed).
	OrderedBytesDescNullsFirst
	// OrderedBytesDescNullsLast sorts descending; NULL sorts AFTER.
	OrderedBytesDescNullsLast
)

func (d OrderedBytesDirection) IsAscending() bool

func (d OrderedBytesDirection) String() string

type OrdinalBakeError ¶

type OrdinalBakeError struct {
	Ordinal   int
	ChildType Type   // the child's flowed type (nil for a nil child)
	Reason    string // which precondition failed: nil child / non-record child / out of range
}

OrdinalBakeError is the loud construction-time error NewFieldValueOfOrdinal returns when the requested ordinal cannot be resolved against the child's flowed type — the Go analog of Java's resolveFieldPath raising SemanticException(FIELD_ACCESS_INPUT_NON_RECORD_TYPE) for a non-record child and IndexOutOfBoundsException for an out-of-range ordinal (FieldValue.java:273-296). Never a silent fallback: a bake failure is a planner bug, not a NULL.

func (e *OrdinalBakeError) Error() string

type OrdinalResolutionError ¶

type OrdinalResolutionError struct {
	Field     string
	Ordinal   int
	Available []string
}

OrdinalResolutionError is the loud internal error (RFC-173 Slice 1) raised when a FieldValue's column cannot be resolved against the authoritative ordinal runtime row. Authority + a silent name-map fallback would mean a resolution bug never surfaces, so this is a query error, not a NULL. Ordinal is the resolved ordinal, or -1 for a flat-reference (name->ordinal) miss. Available carries the row type's column names (when the row exposes them) so the failure is diagnosable from the message alone.

func (e *OrdinalResolutionError) Error() string

type OrdinalRow ¶

type OrdinalRow interface {
	Get(ordinal int) (any, bool)
	GetByName(name string) (any, bool)
}

OrdinalRow is the RFC-173 ordinal-model runtime row FieldValue.Evaluate reads on the authoritative (non-join) frontier, in place of the legacy name-keyed map[string]any. It is satisfied structurally by executor.PositionalRow, which lives in a higher layer — the interface here avoids the import cycle.

Get(ordinal) is the primary path: a FieldValue with a typed child resolves its column to an ordinal (resolveOrdinal, against the child Type) and reads the slot positionally — Java's MessageHelpers.getFieldValueForFieldOrdinals. GetByName(name) serves a Go-only FLAT FieldValue (nil child, no child Type to resolve against): it resolves name->ordinal against the ROW's own Type (the authoritative positional type — e.g. a CTE's renamed columns, positionally aligned to the slots), NOT the legacy name map. Both loud-error (never a silent NULL) on a miss: on the authoritative frontier column existence is validated at plan time (42703), so a runtime miss is a malformed plan.

type OrdinalSeedLegWindow ¶

type OrdinalSeedLegWindow struct {
	Offset int
	Typ    *RecordType
}

OrdinalSeedLegWindow is one leg's window in a pristine ordinal join seed's merged positional layout: the leg's starting slot and its flowed record type (design ruling on the W4-left slice: the layout derivation lives in ONE place — this package — with the planner's existential rebase delegating here and the executor's span derivation pinned to agree by a cross-agreement fixture; independent walks drift, and layout drift is wrong-offset wrong-rows).

type ParameterBinder ¶

type ParameterBinder interface {
	BindParameter(ordinal int, name string) (any, bool)
}

ParameterBinder is an optional eval-context capability: when ParameterValue.Evaluate is called with a context that implements this interface, the parameter is resolved to its bound value. Otherwise Evaluate returns nil (SQL UNKNOWN), which is the safe default for plan-time evaluation where no bindings exist.

type ParameterObjectValue ¶

type ParameterObjectValue struct {
	ParameterName string
	ResultType    Type
}

ParameterObjectValue represents a plan-cache parameter binding — a named placeholder whose value is supplied at execution time via the EvaluationContext. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.ParameterObjectValue`.

Key fields:

• ParameterName: the parameter name (Java: parameterAlias stored as a string, not a CorrelationIdentifier).
• ResultType: the declared Type of the parameter.

Evaluate returns the parameter's value from the eval context's ParameterBinder capability, or nil when no binding exists.

Not correlated: ParameterObjectValue's getCorrelatedToWithoutChildren() returns the empty set in Java — parameter names are NOT CorrelationIdentifiers. The parameter's runtime value is resolved from the EvaluationContext, not from a quantifier binding.

func NewParameterObjectValue(parameterName string, resultType Type) *ParameterObjectValue

func (*ParameterObjectValue) Children() []Value

func (v *ParameterObjectValue) Evaluate(evalCtx any) (any, error)

func (*ParameterObjectValue) GetCorrelatedTo() map[CorrelationIdentifier]struct{}

func (*ParameterObjectValue) Name() string

func (v *ParameterObjectValue) RebaseLeaf(_ CorrelationIdentifier) Value

func (v *ParameterObjectValue) Type() Type

type ParameterValue ¶

type ParameterValue struct {
	Ordinal   int    // 1-based positional index; 0 ⇒ named parameter
	ParamName string // populated when Ordinal == 0
	Typ       Type   // UnknownType until upstream type inference fills it
}

ParameterValue is a placeholder for a prepared-statement parameter — `?` (positional, Ordinal>=1) or `:name` (named, Ordinal=0). Its concrete value is unknown at plan time, so Evaluate returns nil unless the eval context implements ParameterBinder. Treated as non-constant by IsConstantValue, so constant-fold rules decline to fire on `x = ?` / `x = :foo`.

Plan-cache keying: ExplainValue renders a parameter as `?N` / `:name`, which means `WHERE x = ?` and `WHERE x = ?` for two different bind-values share the same Explain string — the seam a future plan cache will key on.

Runtime evaluation goes through the ParameterBinder interface: an evalCtx that implements it (RowEvalContext.Binder) resolves the binding by ordinal/name; without a binder the value degrades to NULL — acceptable only for plan-time / explain-time evaluation.

func NewNamedParameterValue(name string) *ParameterValue

func NewParameterValue(ordinal int) *ParameterValue

func (*ParameterValue) Children() []Value

func (p *ParameterValue) Evaluate(evalCtx any) (any, error)

func (*ParameterValue) Name() string

func (p *ParameterValue) Type() Type

type PatternForLikeValue ¶

type PatternForLikeValue struct {
	PatternChild Value
	EscapeChild  Value
}

PatternForLikeValue is the SQL `patternForLike(pattern, escape)` function — converts a SQL LIKE pattern (with `%` / `_` wildcards and an optional escape char) to a regex-form string, wrapped in `^...$`. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.PatternForLikeValue`.

This Value is part of Java's LIKE-operator surface: Java's `LikeOperatorValue.eval` consumes the regex string produced here via `java.util.regex.Pattern`. Our Go LikeOperatorValue does NOT consume the regex — it routes through the canonical `values.LikeMatch` matcher, which works DIRECTLY on the SQL pattern with `%` / `_` (no regex involvement). PatternForLikeValue is therefore a planner-side surface only in Go: SQL queries that reference `patternForLike(...)` lower to this Value, but the produced regex string isn't consumed by any Go runtime path.

We still port it because:

• It's a SQL-callable function that may appear in user queries (Java's grammar exposes `patternForLike` as a builtin).
• Plan-level equivalence with Java requires the same Value tree shape — even when the actual eval path differs.
• Direct Java → Go SQL plan ports won't fail with "unknown function" when this surface is reached.

Result type: NotNullString (the regex form is always a string).

Eval contract (matches Java):

• patternChild evaluates to a string. If NULL, eval returns NULL.
• escapeChild evaluates to a string OR NULL.
• NULL → standard transformation (no escape).
• exactly 1 character → escape-aware transformation (escape+`_` → literal `_`, escape+`%` → literal `%`).
• other length → returns nil (Java throws SemanticException; Go defers to evaluator-side reporting). Documented as a planner-checked precondition.

Java's `LikeOperatorValue.likeOperation` calls `Pattern.compile(rhs)` WITHOUT DOTALL — Go's default regexp behavior (`.` does NOT match `\n`) is already aligned.

func NewPatternForLikeValue(pattern, escape Value) *PatternForLikeValue

func (v *PatternForLikeValue) Children() []Value

func (v *PatternForLikeValue) Evaluate(evalCtx any) (any, error)

func (*PatternForLikeValue) Name() string

func (*PatternForLikeValue) Type() Type

type PickValue ¶

type PickValue struct {
	Selector     Value
	Alternatives []Value
	// Typ is the result type — Java resolves from alternative types.
	// Defaults to UnknownType.
	Typ Type
}

PickValue picks one of N alternative Values based on an integer selector. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.PickValue`.

PickValue{Selector: 1, Alternatives: [a, b, c]}.Evaluate(ctx)
  ↔  Alternatives[1].Evaluate(ctx) = b.Evaluate(ctx)

Used by the planner for case-style branching where the selector is computed at runtime (e.g. switching between alternative projection shapes based on row context).

CONFORMANCE: matches Java's eval — Selector evaluates to an integer; alternatives[selector] is then evaluated. NULL selector → NULL. Out-of-bounds selector returns nil (defensive; Java would throw IndexOutOfBoundsException — Go swallows for the row-eval contract).

Type is the bound result type (Java's constructor resolves it from the alternatives' types — promotion lattice merge).

func NewPickValue(selector Value, alternatives []Value, resultType Type) *PickValue

func (v *PickValue) Children() []Value

func (v *PickValue) Evaluate(evalCtx any) (any, error)

func (*PickValue) Name() string

func (v *PickValue) Type() Type

type PrimitiveType ¶

type PrimitiveType struct {
	TypeCode TypeCode
	Nullable bool
}

PrimitiveType is the Type impl for scalar types (INT, BOOLEAN, STRING, …). Two PrimitiveType values are Equal iff their Code + Nullable match.

func NewPrimitiveType(code TypeCode, nullable bool) *PrimitiveType

func (p *PrimitiveType) Code() TypeCode

func (p *PrimitiveType) Equals(other Type) bool

func (p *PrimitiveType) IsNullable() bool

func (p *PrimitiveType) String() string

type PromoteValue ¶

type PromoteValue struct {
	Child  Value
	Target Type
}

PromoteValue wraps a child Value to coerce it to a target SQL type when the analyzer inserts an implicit conversion. E.g. `int_col = 5.0` rewrites to `PromoteValue(int_col, FLOAT) = 5.0` so the comparison sees two FLOATs.

Distinct from CastValue: Cast is an explicit `CAST(x AS T)` that the user wrote; Promote is machine-inserted and cost-modelled separately. Mirrors Java's `PromoteValue`.

Evaluate currently delegates to Child.Evaluate — cmpAny already promotes numerics at runtime, so an explicit Promote in the tree is a no-op evaluation-wise. The value is in having the coercion visible at plan time so rule matchers can simplify `Promote(x, x.Type)` → `x`.

func NewPromoteValue(child Value, target Type) *PromoteValue

func (p *PromoteValue) Children() []Value

func (p *PromoteValue) Evaluate(evalCtx any) (any, error)

func (*PromoteValue) Name() string

func (p *PromoteValue) Type() Type

type QuantifiedObjectValue ¶

type QuantifiedObjectValue struct {
	Correlation CorrelationIdentifier
	// Typ is the row type (struct shape) this quantifier produces —
	// a *RecordType on the typed frontier (RFC-173; the translator
	// stamps it from the inner expression's result type), or
	// UnknownType where inference hasn't reached.
	Typ Type
}

QuantifiedObjectValue represents "the current row of the quantifier identified by Correlation". Emitted by the analyzer for references like `t` in `SELECT t.col FROM tbl AS t` — the parent expression (`t.col`) then projects a FieldValue with operand = QuantifiedObjectValue{Correlation: t}.

Mirrors Java's `QuantifiedObjectValue`. Evaluate reads the row directly out of the eval context when it's a `map[CorrelationIdentifier]map[string]any` (the multi-source shape); for the single-source `map[string]any` shape it returns the map verbatim so downstream FieldValue lookups can index into it.

func NewQuantifiedObjectValue(corr CorrelationIdentifier) *QuantifiedObjectValue

func NewQuantifiedObjectValueOfType(corr CorrelationIdentifier, typ Type) *QuantifiedObjectValue

func (*QuantifiedObjectValue) Children() []Value

func (q *QuantifiedObjectValue) Evaluate(evalCtx any) (any, error)

func (q *QuantifiedObjectValue) GetCorrelatedTo() map[CorrelationIdentifier]struct{}

func (*QuantifiedObjectValue) Name() string

func (q *QuantifiedObjectValue) RebaseLeaf(targetAlias CorrelationIdentifier) Value

func (q *QuantifiedObjectValue) Type() Type

type QuantifiedRecordValue ¶

type QuantifiedRecordValue struct {
	Alias      CorrelationIdentifier
	ResultType Type
}

QuantifiedRecordValue represents the entire QUERIED RECORD flowing from a Quantifier — the FDBQueriedRecord shape that carries the stored protobuf message plus version + primary-key metadata. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.QuantifiedRecordValue`.

Distinction from QuantifiedObjectValue:

• QuantifiedObjectValue evaluates to the OBJECT bound to the alias — for record-typed quantifiers this is the proto Message, for repeated-field unnest it's the inner element, for non-record types it's the raw datum.
• QuantifiedRecordValue evaluates to the QUERIED RECORD specifically — a record-shaped tuple of (storedRecord, version, primaryKey). Java's eval calls `binding.getQueriedRecord()` rather than `getMessage()` or `getDatum()`.

The two coexist because:

• Record-typed planner reasoning needs the metadata attached to the record (version, PK); QuantifiedRecordValue carries that intent.
• Per-message proto field access uses QuantifiedObjectValue and descends via FieldValue chains.

In Go both Values evaluate identically through the row-shape harness — the executor does not dispatch FDBQueriedRecord vs Message, so only the TYPE-level distinction is live: planner matchers test for the QuantifiedRecordValue marker specifically (e.g. MatchCandidate-side rules that need the full queried record).

Eval contract: returns the queried-record bound to `alias` in the eval context. Go accepts a `map[string]any` keyed by alias name (sharing VersionValue / IncarnationValue's harness pattern); a nil / non-map / missing-key context returns nil.

func NewQuantifiedRecordValue(alias CorrelationIdentifier, resultType Type) *QuantifiedRecordValue

func (*QuantifiedRecordValue) Children() []Value

func (v *QuantifiedRecordValue) Evaluate(evalCtx any) (any, error)

func (v *QuantifiedRecordValue) GetCorrelatedTo() map[CorrelationIdentifier]struct{}

func (*QuantifiedRecordValue) Name() string

func (v *QuantifiedRecordValue) Type() Type

type QueriedValue ¶

type QueriedValue struct {
	RecordTypes []string
	ResultType  Type
}

QueriedValue is a leaf placeholder representing the FROM-clause row context (the "what's been queried"). Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.QueriedValue`.

Used by the planner during semantic resolution: a SELECT * projection lowers to QueriedValue + RecordConstructor over the queried record types' fields. The Value is non-evaluable — specialized planner rewrites resolve it to concrete Field / QuantifiedObject values before reaching the row-eval layer.

Go accepts an optional record-type-name list and a result Type. Both are advisory; the actual type comes from the queried record store's metadata at execution time.

func NewQueriedValue(recordTypes []string, resultType Type) *QueriedValue

func (*QueriedValue) Children() []Value

func (*QueriedValue) Evaluate(any) (any, error)

func (*QueriedValue) Name() string

func (v *QueriedValue) Type() Type

type RangeValue ¶

type RangeValue struct {
	BeginInclusive Value
	EndExclusive   Value
	Step           Value
}

RangeValue is the SQL range(begin, end, step) table-valued function — produces a stream of LONG values from `beginInclusive` (default 0) up to but not including `endExclusive`, stepped by `step` (default 1). Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.RangeValue`.

Java's class is a STREAMING value (`StreamingValue` + `CreatesDynamicTypesValue`) — its primary eval path is `evalAsStream` which returns a `RecordCursor<QueryResult>`. The scalar `eval` method throws because per-row evaluation makes no sense for a table-function. Go mirrors this: Evaluate returns nil per the placeholder pattern, and a separate EvaluateAsStream method materialises the finite range as `[]int64` for testability.

Result type: a 1-column record with LONG-valued column "ID" — the row shape Java's currentRangeValue produces. Go exposes the element type (NotNullLong) directly via Type since record-typed returns are awkward without StreamingValue / record-type sub-shape support; consumers that care about the row shape can wrap in a RecordConstructorValue.

Cardinality is statically known when begin/end/step all evaluate to constants — useful for the cost model to estimate. Go exposes Cardinality() with the same `floorDiv(end-begin, step)` formula Java uses.

func NewRangeValue(begin, end, step Value) *RangeValue

func (r *RangeValue) Cardinality() (int64, bool)

func (r *RangeValue) Children() []Value

func (*RangeValue) Evaluate(any) (any, error)

func (r *RangeValue) EvaluateAsStream(evalCtx any) []int64

func (*RangeValue) Name() string

func (*RangeValue) Type() Type

type RankValue ¶

type RankValue struct {
	WindowedValue
}

RankValue is the SQL RANK() window function — assigns 1-based rank within each partition, sharing rank across ORDER BY ties (and skipping ranks accordingly: 1, 1, 3, 4, 4, 6). Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.RankValue`.

RANK has NO operand arguments — Java's grammar is `RANK() OVER (PARTITION BY ... ORDER BY ...)`; the windowing happens via the surrounding window definition. ArgumentValues is always empty (Java's constructor takes them but RANK's BuiltIn passes empty argumentValues at parse time).

Result type: NotNullLong. RANK over an empty partition still produces 1 for the first row; never NULL.

Eval: window-aware. Go accepts a row-shape evalCtx of

map[string]any{"_rank": int64(N)}

— the test harness pattern. Real execution wires a streaming-window accumulator that increments rank counters per partition; Go exposes the current rank via this side channel so window-tagged Values are testable without the full streaming framework.

func NewRankValue(partitioningValues []Value) *RankValue

func (*RankValue) Evaluate(evalCtx any) (any, error)

func (*RankValue) Name() string

func (*RankValue) Type() Type

func (r *RankValue) WithChildren(newChildren []Value) *RankValue

type ReEnumerationLeg ¶

type ReEnumerationLeg struct {
	Alias   CorrelationIdentifier
	Sources []CorrelationIdentifier
}

ReEnumerationLeg names one leg of a re-enumerated merge level (RFC-077 7.6): the quantifier the leg's columns are anchored to (Alias), and the parent-quantifier aliases whose columns flow into this leg (Sources). For a leg that PASSES THROUGH a quantifier the parent already binds (an original table, or a merge quantifier from a prior level), Sources is the singleton {Alias} — its columns are read straight from the parent. For a NEWLY-CREATED merge quantifier ($m) that collapses ≥2 lower quantifiers, Alias is the new merge alias and Sources is every collapsed quantifier — $m's row carries the UNION of their columns under their source-table-qualified (dotted) names.

type RecordConstructorField ¶

type RecordConstructorField struct {
	Name  string
	Value Value
}

RecordConstructorField pairs a field name with the Value that computes its contents. Named so the output has a struct shape downstream consumers (projections, aggregations) can address by name.

type RecordConstructorValue ¶

type RecordConstructorValue struct {
	Fields []RecordConstructorField

	// AnchoredJoin marks a source-anchored join RESULT value (RFC-077 7.6):
	// the RecordConstructorValue NewAnchoredJoinRecord builds, whose fields are
	// each FieldValue(QuantifiedObjectValue(leg), col) over the enclosing
	// select's OWN immediate join quantifiers. It is the structural successor of
	// the retired opaque merge's Seed provenance bit, carrying the SAME
	// dual-purpose semantics (RFC-077 F2):
	//   - exploration-time HIDING: GetCorrelatedToOfValue does NOT descend into an
	//     anchored-join RC, so its self-bound leg QOVs are excluded from the
	//     value's reported external correlation set (mirroring the retired seed bit's
	//     "report nothing"). Reporting them inflates every enclosing select's
	//     correlation order and tips the ≥4-way STAR past the task budget.
	//   - partition-time RE-EXPOSURE: PartitionSelectRule keeps ALL lower aliases
	//     live for an anchored-join result (the seed never names the real
	//     projection), and AddMergeSeedAliases re-collects the buried leg QOVs by
	//     walking INTO the RC's fields — so a predicate reading a buried column is
	//     classified as spanning, not pushed below the merge (the 0-row bug).
	//
	// An ORDINARY RecordConstructorValue (a SELECT projection) leaves this false:
	// its correlations are real and must be reported. The flag is the honest
	// structural marker that "this RC is a join result, not a user projection",
	// NOT a downstream-observable heuristic — and it is PRESERVED through every
	// Value reconstruction (WithChildren, Replace, RebaseValue, and the value
	// simplifier's RecordConstructor/liftConstructor rebuilds) so the hiding
	// survives SelectMergeRule's flatten-time substitution of nested join legs.
	AnchoredJoin bool
}

RecordConstructorValue constructs a record (struct) from named children. Used by the analyzer for SELECT projection output (`SELECT a, b+1 AS c` → Record{a: a, c: b+1}) and anywhere a tuple-of-values is needed (ORDER BY key groups, aggregate keys).

Mirrors Java's `RecordConstructorValue`.

func NewAnchoredJoinRecord(legs []AnchoredJoinLeg) *RecordConstructorValue

func NewRawRecordConstructorValue(fields ...RecordConstructorField) *RecordConstructorValue

func NewReEnumerationAnchoredRecord(parent *RecordConstructorValue, legs []ReEnumerationLeg) *RecordConstructorValue

func NewRecordConstructorValue(fields ...RecordConstructorField) *RecordConstructorValue

func NewScalarSubqueryAnchoredRecord(outer AnchoredJoinLeg, innerAlias CorrelationIdentifier, scalarColKey string) *RecordConstructorValue

func (r *RecordConstructorValue) Children() []Value

func (r *RecordConstructorValue) Evaluate(evalCtx any) (any, error)

func (*RecordConstructorValue) Name() string

func (r *RecordConstructorValue) Type() Type

type RecordType ¶

type RecordType struct {
	// RecordName is the optional record name. Empty string means
	// anonymous — frequently the case for projection result rows
	// that haven't been bound to a named struct.
	RecordName string
	// Nullable reports whether the record allows NULL — i.e. a
	// nullable column whose type is this RecordType. Anonymous
	// records typically default to nullable since plan-time
	// inference can't always prove non-nullness.
	Nullable bool
	// Fields are the record's fields in declared order. Empty slice
	// means a record with no fields (legal — `RECORD<>` is the unit
	// type). Never nil.
	Fields []Field
	// Legs marks the buried-leg boundaries of a CLUSTERED box leg's flat
	// ordinal concat (RFC-173 item 3): the translator's ordinalLegType walks
	// the box's legs and records each buried source's binding + starting
	// slot, so the ONE layout authority (OrdinalSeedLegWindows) can emit
	// additive per-buried-leg sub-windows — a projection read qualified by a
	// buried alias resolves positionally exactly like a top-level leg's
	// (Java's rewire-by-ordinal: a buried source is just another
	// quantifier's window). Empty for every non-clustered leg type; carries
	// NO identity semantics (Equals/Hash ignore it — layout metadata only).
	Legs []RecordTypeLeg
}

RecordType is the Type impl for struct-shaped data. Mirrors Java's Record nested type. Two RecordType instances are Equal iff their Name + Nullable match AND their Fields slice is element-wise equal (same length, each Field equals at the same index).

Anonymous records (no name) are common — `RECORD<INT, STRING>` produces a RecordType with Name="" and the corresponding Fields. Named records carry a schema-level table or struct name.

func NewRecordType(name string, nullable bool, fields []Field) *RecordType

func OrdinalSeedLegWindows(rc *RecordConstructorValue) (map[string]OrdinalSeedLegWindow, *RecordType)

func (*RecordType) Code() TypeCode

func (r *RecordType) Equals(other Type) bool

func (r *RecordType) FieldIndex(name string) (int, bool)

func (r *RecordType) GetField(ordinal int) (Field, bool)

func (r *RecordType) IsNullable() bool

func (r *RecordType) LookupField(name string) (Field, bool)

func (r *RecordType) String() string

type RecordTypeLeg ¶

type RecordTypeLeg struct {
	Name  string // UPPER binding of the source
	Start int    // its first slot within the carrying type
	Width int    // its column count
}

RecordTypeLeg is one buried source's boundary within a clustered box leg's flat ordinal concat (see RecordType.Legs).

type RecordTypeValue ¶

type RecordTypeValue struct {
	Child Value
}

RecordTypeValue extracts the record-type discriminator from a record. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.RecordTypeValue`.

Used by:

• Type filters (TypeFilterExpression's predicate equivalent at the Value layer): `recordType(record) IN ('OrderHistory', 'Order')` is rewritten to a TypeFilter scan.
• Index-pushdown rules that select an index based on which record types the planner can serve via that index.

The child Value must evaluate to a record-shaped object that carries a "_recordType" or similar discriminator field. Java gets the type-key from the FDBRecordStore's metadata; Go extracts via map lookup for "_recordType" — the convention used by the Go embedded engine's row-shape.

Type is non-null long (the record-type discriminator is an implicit int64 in Java; record-type names map to integer IDs). In practice Go accepts either string or int64 returns.

func NewRecordTypeValue(child Value) *RecordTypeValue

func (v *RecordTypeValue) Children() []Value

func (v *RecordTypeValue) Evaluate(evalCtx any) (any, error)

func (*RecordTypeValue) Name() string

func (*RecordTypeValue) Type() Type

type RegularTranslationMap ¶

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

RegularTranslationMap is the immutable map-backed implementation (RegularTranslationMap.java:42-140). Build via NewTranslationMapBuilder.

func (t *RegularTranslationMap) ApplyTranslationFunction(sourceAlias CorrelationIdentifier, leafValue Value) Value

func (t *RegularTranslationMap) ContainsSourceAlias(alias CorrelationIdentifier) bool

func (t *RegularTranslationMap) DefinesOnlyIdentities() bool

type RelationType ¶

type RelationType struct {
	// InnerType is the row type. nil for erased relations.
	InnerType Type
}

RelationType is the type of a stream of rows — typically the result of SELECT, the materialised value of a CTE, or the type of a subquery. Mirrors Java's `Type.Relation`.

Always non-nullable: a relation is always defined as a stream of rows, even if that stream happens to be empty. NULL relations don't exist in the type system. WithNullability(true) on a RelationType panics.

InnerType is the type of each row in the stream — typically a RecordType. nil InnerType means "erased" — Java treats this as "the inner type was once known but has been intentionally dropped" (e.g. when crossing an API boundary that doesn't preserve it). Two erased relations compare equal regardless of what their inner types USED to be.

func NewRelationType(inner Type) *RelationType

func (*RelationType) Code() TypeCode

func (r *RelationType) Equals(other Type) bool

func (r *RelationType) IsErased() bool

func (*RelationType) IsNullable() bool

func (r *RelationType) String() string

type ResolvedAccessor ¶

type ResolvedAccessor struct {
	// Field is the PER-STEP display name (Java ResolvedAccessor.getField();
	// "" = pure ordinal access, Java's null name). NOT part of the path's
	// identity — the S3-W3 flip landed Java's ordinal-only element equality
	// (FieldValue.java:675-689); the name survives for the coexistence
	// window's name-model reads (descendResolvedPath map descent,
	// nameReadRootKey, the §5 oracle) and Explain rendering, and dies with
	// them in S4.
	Field   string
	Ordinal int
}

ResolvedAccessor is the construction-time-resolved accessor a BAKED FieldValue carries — Java's FieldValue.ResolvedAccessor (FieldValue.java:~630), whose equals/hashCode are ordinal-only. Deliberately minimal for Slice 2's 2-way wedge (a single ordinal); Slice 3 widens it to a multi-accessor path (Java's FieldPath + the compose rule) when nested/buried ordinal paths land.

IMMUTABLE after construction: FieldValue copy sites deliberately SHARE the pointer (withChildren, the pullup/pushdown passthrough copies). Any future change to the accessor — including Slice 3's path widening — must REPLACE it with a new value, never mutate in place, or every shared copy silently changes identity (review convention pin).

type RowEvalContext ¶

type RowEvalContext struct {
	Datum map[string]any
	// Positional is the RFC-173 Slice 1 authoritative ordinal-model row for the
	// non-join frontier. When non-nil, FieldValue resolution goes through the
	// ordinal path (resolveOrdinal / GetByName against the row's own type) BEFORE
	// the name-keyed Datum — a loud OrdinalResolutionError on a miss, NO name-map
	// fallback (RFC-173). It is the single frontier quantifier's row: an outer
	// correlation still resolves via Correlations first, and only an unbound
	// (frontier) quantifier reference falls through to this row.
	Positional       OrdinalRow
	Binder           ParameterBinder
	Correlations     CorrelationBinder
	ScalarSubqueries map[CorrelationIdentifier]any // pre-evaluated scalar subquery results
	// Strict turns a local field-reference miss (a top-level FieldValue whose
	// name is absent from Datum) from a silent nil into a reported violation
	// via ReportUnresolvedReference. It is set ONLY when evaluating against a
	// row whose key set is complete — i.e. a computed/synthetic row (aggregate
	// output, projection, join-merge) that has no proto-style optional-field
	// omissions, where an absent name is unambiguously an unresolved reference
	// rather than a legitimate SQL NULL. Base-record rows (which legitimately
	// omit unset optional fields) leave this false. See RFC-048 W1.
	Strict bool
}

RowEvalContext is a composite evaluation context for Value.Evaluate that satisfies FieldValue (datum map), ParameterValue (ParameterBinder), and CorrelationBinder. Pass this when evaluating expressions that mix field references, prepared-statement parameters, and correlation bindings (e.g. InJoin explode aliases).

func (r *RowEvalContext) BindParameter(ordinal int, name string) (any, bool)

func (r *RowEvalContext) GetCorrelationBinding(id CorrelationIdentifier) (any, bool)

type RowNumberHighOrderValue ¶

type RowNumberHighOrderValue struct {
	EfSearch           *int
	IsReturningVectors *bool
}

RowNumberHighOrderValue is a partially-applied ROW_NUMBER() window function — a curried form that carries the optional HNSW configuration parameters (EfSearch + IsReturningVectors) ahead of the actual partition + argument values. Mirrors Java's `com.apple.foundationdb.record.query.plan.cascades.values.RowNumberHighOrderValue`.

Usage flow (matches Java's higher-order resolution):

1. Parser encounters `ROW_NUMBER(ef_search: 100)` — this constructs a RowNumberHighOrderValue with the configuration baked in, but no partition or argument values yet.
2. Higher-order Apply receives the partition + argument values (typically the OVER clause's PARTITION BY + ORDER BY columns).
3. Apply produces a fully-configured RowNumberValue with all four pieces (partition, argument, ef_search, is_returning_vectors).

The high-order pattern lets configuration parameters be specified separately from the window specification — Java's `OPTIONS` clause supports `ROW_NUMBER(ef_search: 100) OVER (PARTITION BY ...)`.

LEAF Value: takes no children. The carried HNSW configuration is not Value-typed — it's static metadata.

Eval is a placeholder — the real Apply path lands when the parser + higher-order resolution machinery is in place. RowNumberHighOrderValue itself never produces row-numbered output; it produces a RowNumberValue when applied.

func NewRowNumberHighOrderValue(efSearch *int, isReturningVectors *bool) *RowNumberHighOrderValue

func (h *RowNumberHighOrderValue) Apply(partitioningValues, argumentValues []Value) *RowNumberValue

func (*RowNumberHighOrderValue) Children() []Value

func (*RowNumberHighOrderValue) Evaluate(any) (any, error)

func (*RowNumberHighOrderValue) Name() string

func (*RowNumberHighOrderValue) Type() Type

type RowNumberValue ¶