expr

type AggNode ¶

type AggNode struct {
	Op    AggOp
	Inner Expr
	Alias string
}

AggNode is a column-level aggregation used by GroupBy().Agg. It is a concrete public struct rather than an ExprNode: Agg accepts only AggNode values, so passing a non-aggregate expression is a compile-time error. Op is the reduction, Inner is the expression being reduced, and Alias is the output column name (empty means "derive a default").

func (a AggNode) As(name string) AggNode

func (a AggNode) String() string

type AggOp ¶

type AggOp uint8

const (
	AggOpInvalid AggOp = iota

	AggOpCount
	AggOpSum
	AggOpMean
	AggOpMin
	AggOpMax
)

func (op AggOp) String() string

type AliasNode ¶

type AliasNode struct {
	Name  string
	Inner ExprNode
}

AliasNode renames the result of Inner. The output type and value are passed through unchanged; project operators are responsible for using Name when assembling the output schema.

func (a AliasNode) Children() []ExprNode

func (a AliasNode) DataType(s *schema.Schema) (arrow.DataType, error)

func (a AliasNode) String() string

type BinaryNode ¶

type BinaryNode struct {
	Op    BinaryOp
	Left  ExprNode
	Right ExprNode
}

BinaryNode is the canonical comparison/logical/arithmetic node. The Op determines result-type rules: comparisons and logical ops produce bool; arithmetic ops use promoteNumeric on the operand types.

func (b BinaryNode) Children() []ExprNode

func (b BinaryNode) DataType(s *schema.Schema) (arrow.DataType, error)

func (b BinaryNode) String() string

type BinaryOp ¶

type BinaryOp uint8

const (
	BinaryOpInvalid BinaryOp = iota

	BinaryOpEq
	BinaryOpNeq
	BinaryOpLt
	BinaryOpLte
	BinaryOpGt
	BinaryOpGte

	BinaryOpAnd
	BinaryOpOr

	BinaryOpAdd
	BinaryOpSub
	BinaryOpMul
	BinaryOpDiv
)

func (op BinaryOp) String() string

type CastNode ¶

type CastNode struct {
	Inner ExprNode
	Type  arrow.DataType
}

CastNode forces the output type of Inner to Type. Bind-time validation only checks that the inner expression resolves; runtime evaluation must verify the cast is supported and report failures.

func (c CastNode) Children() []ExprNode

func (c CastNode) DataType(s *schema.Schema) (arrow.DataType, error)

func (c CastNode) String() string

type ColumnNode ¶

type ColumnNode struct {
	Name string
}

ColumnNode references an input column by name. Its output type is resolved against the schema at bind time.

func (c ColumnNode) Children() []ExprNode

func (c ColumnNode) DataType(s *schema.Schema) (arrow.DataType, error)

func (c ColumnNode) String() string

type Expr ¶

type Expr struct {
	Node ExprNode
}

Expr is the public, transparent wrapper around an expression tree node. The exported Node field holds the root ExprNode, so the tree is fully inspectable, serializable, and pattern-matchable by external callers. Fluent methods compose new Expr values left-to-right without mutating the receiver.

func Col(name string) Expr

func Float32(v float32) Expr

func Float64(v float64) Expr

func Int8(v int8) Expr

func Int16(v int16) Expr

func Int32(v int32) Expr

func Int64(v int64) Expr

func Lit(v any) Expr

func LitTimestamp(t time.Time, tz string) Expr

func Uint8(v uint8) Expr

func Uint16(v uint16) Expr

func Uint32(v uint32) Expr

func Uint64(v uint64) Expr

func (e Expr) Add(other Expr) Expr

func (e Expr) And(other Expr) Expr

func (e Expr) As(name string) Expr

func (e Expr) Cast(t arrow.DataType) Expr

func (e Expr) Count() AggNode

func (e Expr) Div(other Expr) Expr

func (e Expr) Eq(other Expr) Expr

func (e Expr) Gt(other Expr) Expr

func (e Expr) Gte(other Expr) Expr

func (e Expr) IsNotNull() Expr

func (e Expr) IsNull() Expr

func (e Expr) Lt(other Expr) Expr

func (e Expr) Lte(other Expr) Expr

func (e Expr) Max() AggNode

func (e Expr) Mean() AggNode

func (e Expr) Min() AggNode

func (e Expr) Mul(other Expr) Expr

func (e Expr) Neg() Expr

func (e Expr) Neq(other Expr) Expr

func (e Expr) Not() Expr

func (e Expr) Or(other Expr) Expr

func (e Expr) String() string

func (e Expr) Sub(other Expr) Expr

func (e Expr) Sum() AggNode

type ExprNode ¶

type ExprNode interface {
	String() string
	Children() []ExprNode
	DataType(s *schema.Schema) (arrow.DataType, error)
}

ExprNode is the interface implemented by every node in the public expression tree. Unlike the previous internal design it carries no unexported marker: the node types are a public, inspectable, serializable contract, so external optimizer passes and deserializers may introduce their own implementations.

Children returns this node's direct child nodes in evaluation order and may return nil for leaves. DataType resolves the node's Arrow output type against the input schema without evaluating it.

func Rewrite(n ExprNode, fn func(ExprNode) ExprNode) ExprNode

type LiteralNode ¶

type LiteralNode struct {
	Value any
	Type  arrow.DataType
}

LiteralNode is a scalar constant. Type is resolved at construction so that later DataType() calls do not need to re-infer from the Go value.

func (l LiteralNode) Children() []ExprNode

func (l LiteralNode) DataType(_ *schema.Schema) (arrow.DataType, error)

func (l LiteralNode) String() string

type SortKey ¶

type SortKey struct {
	Column     string
	Descending bool
	NullsFirst bool
}

SortKey describes one column of a multi-column sort: which column, ascending vs descending, and where nulls land. Build one with By and refine it with the fluent Desc / WithNullsFirst methods.

func By(column string) SortKey

func (k SortKey) Desc() SortKey

func (k SortKey) WithNullsFirst() SortKey

type UnaryNode ¶

type UnaryNode struct {
	Op    UnaryOp
	Inner ExprNode
}

UnaryNode applies a single-operand operator. Logical and null-test ops return bool; arithmetic negation preserves the operand type.

func (u UnaryNode) Children() []ExprNode

func (u UnaryNode) DataType(s *schema.Schema) (arrow.DataType, error)

func (u UnaryNode) String() string

type UnaryOp ¶

type UnaryOp uint8

const (
	UnaryOpInvalid UnaryOp = iota

	UnaryOpNot
	UnaryOpNeg
	UnaryOpIsNull
	UnaryOpIsNotNull
)

func (op UnaryOp) String() string