expr

package

Go to main page

Versions in this module

v0

v0.4.0

Aug 2, 2025

v0.3.1

Aug 1, 2025

Changes in this version

+ type ArithmeticArray interface

+ IsNull func(int) bool

+ Len func() int

+ Value func(int) T

+ type ArithmeticBuilder interface

+ Append func(T)

+ AppendNull func()

+ NewArray func() arrow.Array

+ Release func()

+ type BooleanComparator struct

+ func (c *BooleanComparator) Compare(arr arrow.Array, i, j int) int

+ func (c *BooleanComparator) CompareValues(v1, v2 interface{}) int

+ type Comparator interface

+ Compare func(arr arrow.Array, i, j int) int

+ CompareValues func(v1, v2 interface{}) int

+ type Float64Comparator struct

+ func (c *Float64Comparator) Compare(arr arrow.Array, i, j int) int

+ func (c *Float64Comparator) CompareValues(v1, v2 interface{}) int

+ type Int64Comparator struct

+ func (c *Int64Comparator) Compare(arr arrow.Array, i, j int) int

+ func (c *Int64Comparator) CompareValues(v1, v2 interface{}) int

+ type SortKey struct

+ type StringComparator struct

+ func (c *StringComparator) Compare(arr arrow.Array, i, j int) int

+ func (c *StringComparator) CompareValues(v1, v2 interface{}) int

+ type Type int

type WindowFunctionExpr

+ func CumeDist() *WindowFunctionExpr

+ func NthValue(expr Expr, n int) *WindowFunctionExpr

+ func Ntile(buckets int) *WindowFunctionExpr

+ func PercentRank() *WindowFunctionExpr

type WindowSpec

+ func (w *WindowSpec) Groups(frame *WindowFrame) *WindowSpec

v0.3.0

Jul 27, 2025

Changes in this version

+ func ExpressionToColumnName(expr Expr) string

+ func ValidateExpressionContext(expr Expr, ctx EvaluationContext) error

+ type AggregationContext struct

+ func BuildContextFromAggregations(aggregations []*AggregationExpr) *AggregationContext

+ func NewAggregationContext() *AggregationContext

+ func (ac *AggregationContext) AddMapping(exprStr, columnName string)

+ func (ac *AggregationContext) AllMappings() map[string]string

+ func (ac *AggregationContext) Clear()

+ func (ac *AggregationContext) GetColumnName(exprStr string) (string, bool)

+ func (ac *AggregationContext) GetExpression(columnName string) (string, bool)

+ func (ac *AggregationContext) HasMapping(exprStr string) bool

+ func (ac *AggregationContext) String() string

type AggregationExpr

+ func (a *AggregationExpr) Abs() *FunctionExpr

+ func (a *AggregationExpr) Add(other Expr) *BinaryExpr

+ func (a *AggregationExpr) And(other Expr) *BinaryExpr

+ func (a *AggregationExpr) Ceil() *FunctionExpr

+ func (a *AggregationExpr) Div(other Expr) *BinaryExpr

+ func (a *AggregationExpr) Eq(other Expr) *BinaryExpr

+ func (a *AggregationExpr) Floor() *FunctionExpr

+ func (a *AggregationExpr) Ge(other Expr) *BinaryExpr

+ func (a *AggregationExpr) Gt(other Expr) *BinaryExpr

+ func (a *AggregationExpr) Le(other Expr) *BinaryExpr

+ func (a *AggregationExpr) Log() *FunctionExpr

+ func (a *AggregationExpr) Lt(other Expr) *BinaryExpr

+ func (a *AggregationExpr) Mul(other Expr) *BinaryExpr

+ func (a *AggregationExpr) Ne(other Expr) *BinaryExpr

+ func (a *AggregationExpr) Neg() *UnaryExpr

+ func (a *AggregationExpr) Not() *UnaryExpr

+ func (a *AggregationExpr) Or(other Expr) *BinaryExpr

+ func (a *AggregationExpr) Round() *FunctionExpr

+ func (a *AggregationExpr) RoundTo(precision Expr) *FunctionExpr

+ func (a *AggregationExpr) Sqrt() *FunctionExpr

+ func (a *AggregationExpr) Sub(other Expr) *BinaryExpr

+ func (a *AggregationExpr) SupportsContext(ctx EvaluationContext) bool

+ type AliasResolver struct

+ func BuildAliasResolver(groupByColumns []string, aggregations []*AggregationExpr, caseInsensitive bool) (*AliasResolver, error)

+ func NewAliasResolver(caseInsensitive bool) *AliasResolver

+ func (ar *AliasResolver) AddAggregation(aggExpr *AggregationExpr) error

+ func (ar *AliasResolver) AddGroupByColumn(columnName string)

+ func (ar *AliasResolver) GenerateDefaultName(aggExpr *AggregationExpr) string

+ func (ar *AliasResolver) GetAllAvailableAliases() []string

+ func (ar *AliasResolver) GetAvailableAliases(columnName string) []string

+ func (ar *AliasResolver) GetColumnNameFromExpression(exprStr string) (string, bool)

+ func (ar *AliasResolver) ResolveAlias(alias string) (string, bool)

+ func (ar *AliasResolver) ValidateAlias(alias string) error

type BinaryExpr

+ func NewBinaryExpr(left Expr, op BinaryOp, right Expr) *BinaryExpr

+ func (b *BinaryExpr) Eq(other Expr) *BinaryExpr

+ func (b *BinaryExpr) Ge(other Expr) *BinaryExpr

+ func (b *BinaryExpr) Gt(other Expr) *BinaryExpr

+ func (b *BinaryExpr) Le(other Expr) *BinaryExpr

+ func (b *BinaryExpr) Lt(other Expr) *BinaryExpr

+ func (b *BinaryExpr) Ne(other Expr) *BinaryExpr

+ func (b *BinaryExpr) SupportsContext(ctx EvaluationContext) bool

type CaseExpr

+ func (c *CaseExpr) SupportsContext(ctx EvaluationContext) bool

type ColumnExpr

+ func (c *ColumnExpr) DateAdd(intervalExpr *IntervalExpr) *FunctionExpr

+ func (c *ColumnExpr) DateSub(intervalExpr *IntervalExpr) *FunctionExpr

+ func (c *ColumnExpr) SupportsContext(ctx EvaluationContext) bool

+ type ContextualExpr interface

+ SupportsContext func(ctx EvaluationContext) bool

+ type EvaluationContext int

+ const GroupContext

+ const RowContext

+ func (ec EvaluationContext) String() string

type Evaluator

+ func (e *Evaluator) EvaluateBooleanWithContext(expr Expr, columns map[string]arrow.Array, ctx EvaluationContext) (arrow.Array, error)

+ func (e *Evaluator) EvaluateWithContext(expr Expr, columns map[string]arrow.Array, ctx EvaluationContext) (arrow.Array, error)

type FunctionExpr

+ func DateAdd(dateExpr Expr, intervalExpr *IntervalExpr) *FunctionExpr

+ func DateDiff(startDate, endDate Expr, unit string) *FunctionExpr

+ func DateSub(dateExpr Expr, intervalExpr *IntervalExpr) *FunctionExpr

+ func NewFunction(name string, args ...Expr) *FunctionExpr

+ func (f *FunctionExpr) DateAdd(intervalExpr *IntervalExpr) *FunctionExpr

+ func (f *FunctionExpr) DateSub(intervalExpr *IntervalExpr) *FunctionExpr

+ func (f *FunctionExpr) SupportsContext(ctx EvaluationContext) bool

+ type HavingValidator struct

+ func BuildHavingValidatorWithAlias(groupByColumns []string, aggregations []*AggregationExpr, caseInsensitive bool) (*HavingValidator, error)

+ func NewHavingValidator(aggregationContext *AggregationContext, groupByColumns []string) *HavingValidator

+ func NewHavingValidatorWithAlias(aggregationContext *AggregationContext, groupByColumns []string, ...) *HavingValidator

+ func (hv *HavingValidator) GetAvailableAggregations() []string

+ func (hv *HavingValidator) GetAvailableColumns() []string

+ func (hv *HavingValidator) ValidateExpression(expr Expr) error

+ type IntervalExpr struct

+ func Days(value int64) *IntervalExpr

+ func Hours(value int64) *IntervalExpr

+ func Minutes(value int64) *IntervalExpr

+ func Months(value int64) *IntervalExpr

+ func Years(value int64) *IntervalExpr

+ func (i *IntervalExpr) IntervalType() IntervalType

+ func (i *IntervalExpr) String() string

+ func (i *IntervalExpr) SupportsContext(ctx EvaluationContext) bool

+ func (i *IntervalExpr) Type() ExprType

+ func (i *IntervalExpr) Value() int64

+ type IntervalType int

+ const IntervalDays

+ const IntervalHours

+ const IntervalMinutes

+ const IntervalMonths

+ const IntervalYears

type InvalidExpr

+ func (i *InvalidExpr) SupportsContext(ctx EvaluationContext) bool

type LiteralExpr

+ func (l *LiteralExpr) SupportsContext(ctx EvaluationContext) bool

type UnaryExpr

+ func (u *UnaryExpr) SupportsContext(ctx EvaluationContext) bool

type WindowExpr

+ func (w *WindowExpr) SupportsContext(ctx EvaluationContext) bool

type WindowFunctionExpr

+ func (w *WindowFunctionExpr) SupportsContext(ctx EvaluationContext) bool

+ type WindowParallelConfig struct

+ AdaptiveParallelization bool

+ MaxWorkers int

+ MinPartitionsForParallel int

+ MinRowsForParallelSort int

+ func DefaultWindowParallelConfig() *WindowParallelConfig

v0.2.0

Jul 18, 2025

Changes in this version

+ const AggNameCount

+ const AggNameMax

+ const AggNameMean

+ const AggNameMin

+ const AggNameSum

type AggregationExpr

+ func (a *AggregationExpr) Over(window *WindowSpec) *WindowExpr

+ type BoundaryType int

+ const BoundaryCurrentRow

+ const BoundaryFollowing

+ const BoundaryPreceding

+ const BoundaryUnboundedFollowing

+ const BoundaryUnboundedPreceding

type ColumnExpr

+ func (c *ColumnExpr) Day() *FunctionExpr

+ func (c *ColumnExpr) Hour() *FunctionExpr

+ func (c *ColumnExpr) Minute() *FunctionExpr

+ func (c *ColumnExpr) Month() *FunctionExpr

+ func (c *ColumnExpr) Second() *FunctionExpr

+ func (c *ColumnExpr) Year() *FunctionExpr

type Evaluator

+ func (e *Evaluator) EvaluateWindow(expr *WindowExpr, columns map[string]arrow.Array) (arrow.Array, error)

type ExprType

+ const ExprWindow

+ const ExprWindowFunction

+ type FrameBoundary struct

+ func CurrentRow() *FrameBoundary

+ func Following(offset int) *FrameBoundary

+ func Preceding(offset int) *FrameBoundary

+ func UnboundedFollowing() *FrameBoundary

+ func UnboundedPreceding() *FrameBoundary

+ func (b *FrameBoundary) String() string

+ type FrameType int

+ const FrameTypeGroups

+ const FrameTypeRange

+ const FrameTypeRows

type FunctionExpr

+ func Day(expr Expr) *FunctionExpr

+ func Hour(expr Expr) *FunctionExpr

+ func Minute(expr Expr) *FunctionExpr

+ func Month(expr Expr) *FunctionExpr

+ func Second(expr Expr) *FunctionExpr

+ func Year(expr Expr) *FunctionExpr

+ func (f *FunctionExpr) Day() *FunctionExpr

+ func (f *FunctionExpr) Hour() *FunctionExpr

+ func (f *FunctionExpr) Minute() *FunctionExpr

+ func (f *FunctionExpr) Month() *FunctionExpr

+ func (f *FunctionExpr) Second() *FunctionExpr

+ func (f *FunctionExpr) Year() *FunctionExpr

+ type OrderByExpr struct

+ type WindowExpr struct

+ func (w *WindowExpr) String() string

+ func (w *WindowExpr) Type() ExprType

+ type WindowFrame struct

+ func Between(start, end *FrameBoundary) *WindowFrame

+ func (f *WindowFrame) String() string

+ type WindowFunctionExpr struct

+ func DenseRank() *WindowFunctionExpr

+ func FirstValue(expr Expr) *WindowFunctionExpr

+ func Lag(expr Expr, offset int) *WindowFunctionExpr

+ func LastValue(expr Expr) *WindowFunctionExpr

+ func Lead(expr Expr, offset int) *WindowFunctionExpr

+ func Rank() *WindowFunctionExpr

+ func RowNumber() *WindowFunctionExpr

+ func (w *WindowFunctionExpr) Over(window *WindowSpec) *WindowExpr

+ func (w *WindowFunctionExpr) String() string

+ func (w *WindowFunctionExpr) Type() ExprType

+ type WindowSpec struct

+ func NewWindow() *WindowSpec

+ func (w *WindowSpec) OrderBy(column string, ascending bool) *WindowSpec

+ func (w *WindowSpec) PartitionBy(columns ...string) *WindowSpec

+ func (w *WindowSpec) Range(frame *WindowFrame) *WindowSpec

+ func (w *WindowSpec) Rows(frame *WindowFrame) *WindowSpec

+ func (w *WindowSpec) String() string

v0.1.0

Jul 16, 2025

Changes in this version

+ type AggregationExpr struct

+ func Count(column Expr) *AggregationExpr

+ func Max(column Expr) *AggregationExpr

+ func Mean(column Expr) *AggregationExpr

+ func Min(column Expr) *AggregationExpr

+ func Sum(column Expr) *AggregationExpr

+ func (a *AggregationExpr) AggType() AggregationType

+ func (a *AggregationExpr) Alias() string

+ func (a *AggregationExpr) As(alias string) *AggregationExpr

+ func (a *AggregationExpr) Column() Expr

+ func (a *AggregationExpr) String() string

+ func (a *AggregationExpr) Type() ExprType

+ type AggregationType int

+ const AggCount

+ const AggMax

+ const AggMean

+ const AggMin

+ const AggSum

+ type BinaryExpr struct

+ func (b *BinaryExpr) Abs() *FunctionExpr

+ func (b *BinaryExpr) Add(other Expr) *BinaryExpr

+ func (b *BinaryExpr) And(other Expr) *BinaryExpr

+ func (b *BinaryExpr) Ceil() *FunctionExpr

+ func (b *BinaryExpr) Cos() *FunctionExpr

+ func (b *BinaryExpr) Div(other Expr) *BinaryExpr

+ func (b *BinaryExpr) Floor() *FunctionExpr

+ func (b *BinaryExpr) Left() Expr

+ func (b *BinaryExpr) Log() *FunctionExpr

+ func (b *BinaryExpr) Mul(other Expr) *BinaryExpr

+ func (b *BinaryExpr) Op() BinaryOp

+ func (b *BinaryExpr) Or(other Expr) *BinaryExpr

+ func (b *BinaryExpr) Right() Expr

+ func (b *BinaryExpr) Round() *FunctionExpr

+ func (b *BinaryExpr) RoundTo(precision Expr) *FunctionExpr

+ func (b *BinaryExpr) Sin() *FunctionExpr

+ func (b *BinaryExpr) Sqrt() *FunctionExpr

+ func (b *BinaryExpr) String() string

+ func (b *BinaryExpr) Sub(other Expr) *BinaryExpr

+ func (b *BinaryExpr) Type() ExprType

+ type BinaryOp int

+ const OpAdd

+ const OpAnd

+ const OpDiv

+ const OpEq

+ const OpGe

+ const OpGt

+ const OpLe

+ const OpLt

+ const OpMul

+ const OpNe

+ const OpOr

+ const OpSub

+ type CaseExpr struct

+ func Case() *CaseExpr

+ func (c *CaseExpr) Else(value Expr) *CaseExpr

+ func (c *CaseExpr) ElseValue() Expr

+ func (c *CaseExpr) String() string

+ func (c *CaseExpr) Type() ExprType

+ func (c *CaseExpr) When(condition, value Expr) *CaseExpr

+ func (c *CaseExpr) Whens() []CaseWhen

+ type CaseWhen struct

+ type ColumnExpr struct

+ func Col(name string) *ColumnExpr

+ func (c *ColumnExpr) Abs() *FunctionExpr

+ func (c *ColumnExpr) Add(other Expr) *BinaryExpr

+ func (c *ColumnExpr) CastToBool() *FunctionExpr

+ func (c *ColumnExpr) CastToFloat64() *FunctionExpr

+ func (c *ColumnExpr) CastToInt64() *FunctionExpr

+ func (c *ColumnExpr) CastToString() *FunctionExpr

+ func (c *ColumnExpr) Ceil() *FunctionExpr

+ func (c *ColumnExpr) Cos() *FunctionExpr

+ func (c *ColumnExpr) Count() *AggregationExpr

+ func (c *ColumnExpr) Div(other Expr) *BinaryExpr

+ func (c *ColumnExpr) Eq(other Expr) *BinaryExpr

+ func (c *ColumnExpr) Floor() *FunctionExpr

+ func (c *ColumnExpr) Ge(other Expr) *BinaryExpr

+ func (c *ColumnExpr) Gt(other Expr) *BinaryExpr

+ func (c *ColumnExpr) Le(other Expr) *BinaryExpr

+ func (c *ColumnExpr) Length() *FunctionExpr

+ func (c *ColumnExpr) Log() *FunctionExpr

+ func (c *ColumnExpr) Lower() *FunctionExpr

+ func (c *ColumnExpr) Lt(other Expr) *BinaryExpr

+ func (c *ColumnExpr) Max() *AggregationExpr

+ func (c *ColumnExpr) Mean() *AggregationExpr

+ func (c *ColumnExpr) Min() *AggregationExpr

+ func (c *ColumnExpr) Mul(other Expr) *BinaryExpr

+ func (c *ColumnExpr) Name() string

+ func (c *ColumnExpr) Ne(other Expr) *BinaryExpr

+ func (c *ColumnExpr) Neg() *UnaryExpr

+ func (c *ColumnExpr) Not() *UnaryExpr

+ func (c *ColumnExpr) Round() *FunctionExpr

+ func (c *ColumnExpr) RoundTo(precision Expr) *FunctionExpr

+ func (c *ColumnExpr) Sin() *FunctionExpr

+ func (c *ColumnExpr) Sqrt() *FunctionExpr

+ func (c *ColumnExpr) String() string

+ func (c *ColumnExpr) Sub(other Expr) *BinaryExpr

+ func (c *ColumnExpr) Substring(start, length Expr) *FunctionExpr

+ func (c *ColumnExpr) Sum() *AggregationExpr

+ func (c *ColumnExpr) Trim() *FunctionExpr

+ func (c *ColumnExpr) Type() ExprType

+ func (c *ColumnExpr) Upper() *FunctionExpr

+ type Evaluator struct

+ func NewEvaluator(mem memory.Allocator) *Evaluator

+ func (e *Evaluator) Evaluate(expr Expr, columns map[string]arrow.Array) (arrow.Array, error)

+ func (e *Evaluator) EvaluateBoolean(expr Expr, columns map[string]arrow.Array) (arrow.Array, error)

+ type Expr interface

+ String func() string

+ Type func() ExprType

+ type ExprType int

+ const ExprAggregation

+ const ExprBinary

+ const ExprCase

+ const ExprColumn

+ const ExprFunction

+ const ExprInvalid

+ const ExprLiteral

+ const ExprUnary

+ type FunctionExpr struct

+ func Coalesce(exprs ...Expr) *FunctionExpr

+ func Concat(exprs ...Expr) *FunctionExpr

+ func If(condition, thenValue, elseValue Expr) *FunctionExpr

+ func (f *FunctionExpr) Abs() *FunctionExpr

+ func (f *FunctionExpr) Add(other Expr) *BinaryExpr

+ func (f *FunctionExpr) And(other Expr) *BinaryExpr

+ func (f *FunctionExpr) Args() []Expr

+ func (f *FunctionExpr) CastToBool() *FunctionExpr

+ func (f *FunctionExpr) CastToFloat64() *FunctionExpr

+ func (f *FunctionExpr) CastToInt64() *FunctionExpr

+ func (f *FunctionExpr) CastToString() *FunctionExpr

+ func (f *FunctionExpr) Ceil() *FunctionExpr

+ func (f *FunctionExpr) Cos() *FunctionExpr

+ func (f *FunctionExpr) Div(other Expr) *BinaryExpr

+ func (f *FunctionExpr) Eq(other Expr) *BinaryExpr

+ func (f *FunctionExpr) Floor() *FunctionExpr

+ func (f *FunctionExpr) Ge(other Expr) *BinaryExpr

+ func (f *FunctionExpr) Gt(other Expr) *BinaryExpr

+ func (f *FunctionExpr) Le(other Expr) *BinaryExpr

+ func (f *FunctionExpr) Length() *FunctionExpr

+ func (f *FunctionExpr) Log() *FunctionExpr

+ func (f *FunctionExpr) Lower() *FunctionExpr

+ func (f *FunctionExpr) Lt(other Expr) *BinaryExpr

+ func (f *FunctionExpr) Mul(other Expr) *BinaryExpr

+ func (f *FunctionExpr) Name() string

+ func (f *FunctionExpr) Ne(other Expr) *BinaryExpr

+ func (f *FunctionExpr) Neg() *UnaryExpr

+ func (f *FunctionExpr) Not() *UnaryExpr

+ func (f *FunctionExpr) Or(other Expr) *BinaryExpr

+ func (f *FunctionExpr) Round() *FunctionExpr

+ func (f *FunctionExpr) RoundTo(precision Expr) *FunctionExpr

+ func (f *FunctionExpr) Sin() *FunctionExpr

+ func (f *FunctionExpr) Sqrt() *FunctionExpr

+ func (f *FunctionExpr) String() string

+ func (f *FunctionExpr) Sub(other Expr) *BinaryExpr

+ func (f *FunctionExpr) Substring(start, length Expr) *FunctionExpr

+ func (f *FunctionExpr) Trim() *FunctionExpr

+ func (f *FunctionExpr) Type() ExprType

+ func (f *FunctionExpr) Upper() *FunctionExpr

+ type InvalidExpr struct

+ func Invalid(message string) *InvalidExpr

+ func (i *InvalidExpr) Message() string

+ func (i *InvalidExpr) String() string

+ func (i *InvalidExpr) Type() ExprType

+ type LiteralExpr struct

+ func Lit(value interface{}) *LiteralExpr

+ func (l *LiteralExpr) String() string

+ func (l *LiteralExpr) Type() ExprType

+ func (l *LiteralExpr) Value() interface{}

+ type UnaryExpr struct

+ func (u *UnaryExpr) Op() UnaryOp

+ func (u *UnaryExpr) Operand() Expr

+ func (u *UnaryExpr) String() string

+ func (u *UnaryExpr) Type() ExprType

+ type UnaryOp int

+ const UnaryNeg

+ const UnaryNot

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL