exec

Sep 5, 2026

Changes in this version

type CollectSink

+ OutputNames []string

+ SchemaHintStringLengthPos []int

+ SchemaHintWireUnconstrainedPos []bool

Sep 4, 2026

Changes in this version

+ var ForcedWindowSpills atomic.Int64

+ func ForceWindowSpillEvery(n int64) int64

type CollectSink

+ SchemaHintStringLength map[string]int

Sep 4, 2026

Changes in this version

+ var ForcedSortSpills atomic.Int64

+ func ArmJoinFloorProbe() func() JoinFloorSnapshot

+ func ForceSortSpillEvery(n int64) int64

+ type JoinFloorSnapshot struct

+ JoinIndex int64

+ ScanDecodedBatch int64

+ ScanFileLoad int64

+ ScanPooledBuffer int64

+ Seen bool

+ Used int64

Sep 4, 2026

Changes in this version

type SortKey

+ SlotPos int

Sep 4, 2026

Changes in this version

+ var JoinUnroutedProbeFlatBuilds atomic.Int64

Sep 3, 2026

Changes in this version

+ var DecimalBoxedCells atomic.Int64

Sep 3, 2026

Changes in this version

type HashAggregate

+ GroupingCallNames []string

+ GroupingCalls [][]int

Sep 3, 2026

Changes in this version

+ func PublishedGroupKeyNames(groupByCols, groupByOutNames []string, groupByAll bool) []string

Sep 2, 2026

Changes in this version

+ func SinkSurvivesCloning(s Sink) bool

type AggColumn

+ Distinct bool

Sep 2, 2026

Changes in this version

+ var AggregatePartialDrains atomic.Int64

+ var ForcedAggDrains atomic.Int64

+ var RawRowSpillFiles atomic.Int64

+ var SortRunsWritten atomic.Int64

+ var WindowRunsWritten atomic.Int64

+ func ForceAggDrainEvery(n int64) int64

+ func ForceSmallSpillRuns(n int64) func()

Aug 31, 2026

Changes in this version

type HashAggregate

+ GroupByOutNames []string

Aug 30, 2026

Changes in this version

+ const KeyTypeUnresolved

+ func AppendWidenedKeyValue(buf []byte, v *batch.Vector, row int, target batch.TypeID) []byte

+ func KeyTypeAt(types []batch.TypeID, i int, own batch.TypeID) batch.TypeID

+ func WindowDecimalAggMeta(fn WindowFunc, inScale int) (precision, scale int)

type AggColumn

+ OutputPrecision int

+ OutputScale int

type Filter

+ Check func(*batch.RecordBatch) error

type HashJoin

+ KeyTypes []batch.TypeID

+ type Int128Sum = batch.Int128

type ProjectColumn

+ Precision int

+ Scale int

+ VecDecimalEval VecDecimalExpression

+ type VecDecimalExpression func(b *batch.RecordBatch, out *batch.Vector, n int) bool

Aug 29, 2026

Changes in this version

type AggColumn

+ InputColIdx int

+ InputColIdxSet bool

type InFilter

+ func (f *InFilter) SetSyntacticLen(n int)

Aug 28, 2026

Changes in this version

+ var BloomFullRejections atomic.Int64

+ var BloomKeyTypeMismatches atomic.Int64

+ var BloomSelfCheckFailures atomic.Int64

+ var ContainerKeyDrainWrites atomic.Int64

+ var JoinPartitionsEvicted atomic.Int64

+ func AppendBoxedGroupKey(dst []byte, v any, col *parquet.Column) []byte

+ type BloomBuilder struct

+ func NewBloomBuilder(totalRows int) *BloomBuilder

+ func (bb *BloomBuilder) Add(b *batch.RecordBatch, keyCol string) error

+ func (bb *BloomBuilder) Bloom() ([]uint64, uint64)

+ func (bb *BloomBuilder) FilterOp(column string) *BloomFilterOp

+ func (bb *BloomBuilder) Inserted() int64

+ func (bb *BloomBuilder) Resolved() bool

type BloomFilterOp

+ func (op *BloomFilterOp) SelfCheck() error

type CollectSink

+ func (s *CollectSink) ToRowValues() [][]any

+ type DecimalCoerce struct

+ func NewDecimalCoerce(cols []DecimalCoerceColumn) *DecimalCoerce

+ func (d *DecimalCoerce) Clone() UnaryOperator

+ func (d *DecimalCoerce) Close() error

+ func (d *DecimalCoerce) Execute(_ context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (d *DecimalCoerce) Init(_ context.Context) error

+ type DecimalCoerceColumn struct

+ Name string

+ Precision int

+ Scale int

type HashJoin

+ NullAwareAnti bool

type InFilter

+ RowFallback Predicate

type LikeFilter

+ RowFallback Predicate

type NullCheckFilter

+ RowFallback Predicate

type ProjectColumn

+ SourceIdx int

+ SourceIdxSet bool

Aug 25, 2026

Changes in this version

+ const SQLStateInternalError

+ func CatchQueryPanic(ctx context.Context, where string, report func(error))

+ func IsQueryPanicMessage(msg string) bool

+ func QueryIDFromContext(ctx context.Context) string

+ func QueryPanicsRecovered() int64

+ func RecoverQueryPanic(ctx context.Context, where string, r any) error

+ func WithQueryID(ctx context.Context, id string) context.Context

+ type FirstError struct

+ func (f *FirstError) Err() error

+ func (f *FirstError) Set(err error)

+ type QueryPanic struct

+ Stack string

+ Value any

+ Where string

+ func (p *QueryPanic) Error() string

+ func (p *QueryPanic) SQLState() string

+ func (p *QueryPanic) Unwrap() error

Aug 24, 2026

Changes in this version

type CollectSink

+ SchemaHint []parquet.Column

+ SchemaHintWireUnconstrainedDecimal map[string]bool

type InFilter

+ ValueTexts []string

+ func NewInFilterLit(colName string, values []any, texts []string, negate bool) *InFilter

type KernelFilter

+ LitText string

+ func NewKernelFilterLit(colName string, op CompareOp, value any, litText string) *KernelFilter

+ type MatchNothingFilter struct

+ func NewMatchNothingFilter() *MatchNothingFilter

+ func (f *MatchNothingFilter) Clone() UnaryOperator

+ func (f *MatchNothingFilter) Close() error

+ func (f *MatchNothingFilter) Execute(_ context.Context, _ *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (f *MatchNothingFilter) Init(_ context.Context) error

type Predicate

+ func ColumnCompareLit(colName string, op CompareOp, value any, litText string) Predicate

Aug 23, 2026

Changes in this version

+ const CovarKindCorr

+ const CovarKindCovarPop

+ const CovarKindCovarSamp

+ const MaxProbeOutputRows

+ const NoLimit

+ const VarKindStddevPop

+ const VarKindStddevSamp

+ const VarKindVarPop

+ const VarKindVarSamp

+ var ErrCollectBudget = errors.New("collect sink result budget exceeded")

+ var HashOnceRoutedRows atomic.Int64

+ var KeyAssignmentRepairs atomic.Int64

+ var LateMatBatchesEmitted atomic.Int64

+ var LateMatFlattens atomic.Int64

+ var LateMatViewColumns atomic.Int64

+ var LateMatViewColumnsSerialized atomic.Int64

+ var ParallelEmitRuns atomic.Int64

+ var PartitionedAggRuns atomic.Int64

+ var SMJCounterpartAdoptions atomic.Int64

+ var TwoLevelBornFlat atomic.Int64

+ var TwoLevelConversions atomic.Int64

+ var TwoLevelDirectBuilds atomic.Int64

+ func BloomAddBatch(bloom []uint64, bloomMask uint64, b *batch.RecordBatch, keyCol string)

+ func BloomContains(bloom []uint64, mask, hash uint64) bool

+ func BloomHashInt(key int64) uint64

+ func BuildBloomFromBatches(batches []*batch.RecordBatch, keyCol string) (bloom []uint64, bloomMask uint64)

+ func ColumnIndexFallback(b *batch.RecordBatch, name string) int

+ func EnableBoundedOutput(ops []UnaryOperator)

+ func FinalizeCovarianceState(encoded, kind string) (float64, bool)

+ func FinalizeVarianceState(encoded, kind string) (float64, bool)

+ func FlattenForConsumer(b *batch.RecordBatch, consumer any)

+ func FormatAnalyzeStats(stats []*ProfileStats) []string

+ func GatherColumn(dst, src *batch.Vector, sel []uint32)

+ func NewBloomSized(totalRows int) (bloom []uint64, bloomMask uint64)

+ func PauseOrDrainOnHeapBackpressure(ctx context.Context, sink Sink) error

+ func RecoverFatalEval(r any) error

+ func TryPressureDrain(ctx context.Context, sink Sink) (bool, error)

+ func WindowMinMaxType(in parquet.TypeID) (parquet.TypeID, bool)

+ func WithProgressReporter(ctx context.Context, p ProgressReporter) context.Context

+ type AggColumn struct

+ Func AggFunc

+ InputCol string

+ InputCol2 string

+ OutputCol string

+ OutputType parquet.TypeID

+ Percentile float64

+ Separator string

+ type AggFunc int

+ const AggApproxDistinct

+ const AggAvg

+ const AggBoolAnd

+ const AggBoolOr

+ const AggCorr

+ const AggCount

+ const AggCountDistinct

+ const AggCovarPop

+ const AggCovarSamp

+ const AggCovarState

+ const AggCovarStateMerge

+ const AggMax

+ const AggMaxBy

+ const AggMedian

+ const AggMin

+ const AggMinBy

+ const AggMode

+ const AggPercentileCont

+ const AggPercentileDisc

+ const AggStddev

+ const AggStddevPop

+ const AggStringAgg

+ const AggSum

+ const AggVarPop

+ const AggVarState

+ const AggVarStateMerge

+ const AggVariance

+ type BatchSink struct

+ func (s *BatchSink) Batches() []*batch.RecordBatch

+ func (s *BatchSink) Close() error

+ func (s *BatchSink) Consume(_ context.Context, b *batch.RecordBatch) error

+ func (s *BatchSink) Finalize(_ context.Context) error

+ func (s *BatchSink) Init(_ context.Context) error

+ type BatchSource struct

+ func NewBatchSource(batches []*batch.RecordBatch) *BatchSource

+ func (s *BatchSource) Close() error

+ func (s *BatchSource) Init(_ context.Context) error

+ func (s *BatchSource) Next(_ context.Context) (*batch.RecordBatch, error)

+ type BloomFilterOp struct

+ func NewBloomFilterOp(bloom []uint64, bloomMask uint64, keys []string, useIntKey bool) *BloomFilterOp

+ func (op *BloomFilterOp) BloomScanFilter() *BloomScanFilter

+ func (op *BloomFilterOp) Clone() UnaryOperator

+ func (op *BloomFilterOp) Close() error

+ func (op *BloomFilterOp) Execute(_ context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (op *BloomFilterOp) Init(_ context.Context) error

+ func (op *BloomFilterOp) KeyColumns() []string

+ type BloomScanFilter struct

+ Bloom []uint64

+ BloomMask uint64

+ Column string

+ UseIntKey bool

+ type BoundedOutputOperator interface

+ EnableBoundedOutput func()

+ HasPendingOutput func() bool

+ NextOutput func(ctx context.Context) (*batch.RecordBatch, error)

+ type BufferReusingOperator interface

+ ReusesOutputBuffers func() bool

+ type ChainDriver struct

+ func NewChainDriver(ops []UnaryOperator, deliver func(context.Context, *batch.RecordBatch) error) *ChainDriver

+ func (d *ChainDriver) Inspect(fn func(opIdx int, op UnaryOperator, out *batch.RecordBatch)) *ChainDriver

+ func (d *ChainDriver) Push(ctx context.Context, b *batch.RecordBatch) (exhausted bool, err error)

+ func (d *ChainDriver) ReleaseInputs() *ChainDriver

+ type ChainFilter struct

+ Ops []UnaryOperator

+ func NewChainFilter(ops []UnaryOperator) *ChainFilter

+ func (f *ChainFilter) Clone() UnaryOperator

+ func (f *ChainFilter) Close() error

+ func (f *ChainFilter) Execute(ctx context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (f *ChainFilter) Init(ctx context.Context) error

+ type Cloneable interface

+ Clone func() UnaryOperator

+ type ColColFilter struct

+ LeftCol string

+ Op CompareOp

+ RightCol string

+ RowFallback Predicate

+ func NewColColFilter(leftCol, rightCol string, op CompareOp) *ColColFilter

+ func (f *ColColFilter) Clone() UnaryOperator

+ func (f *ColColFilter) Close() error

+ func (f *ColColFilter) Execute(ctx context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (f *ColColFilter) Init(_ context.Context) error

+ type CollectSink struct

+ MaxBytes int64

+ Rows []map[string]any

+ SkipFinalizeToRows bool

+ func (s *CollectSink) Batches() []*batch.RecordBatch

+ func (s *CollectSink) Close() error

+ func (s *CollectSink) Consume(_ context.Context, b *batch.RecordBatch) error

+ func (s *CollectSink) Finalize(_ context.Context) error

+ func (s *CollectSink) Init(_ context.Context) error

+ func (s *CollectSink) Schema() []parquet.Column

+ func (s *CollectSink) ToRows() []map[string]any

+ type CollectorReplaySource struct

+ func (s *CollectorReplaySource) Close() error

+ func (s *CollectorReplaySource) Init(_ context.Context) error

+ func (s *CollectorReplaySource) Next(_ context.Context) (*batch.RecordBatch, error)

+ type Column = parquet.Column

+ type ColumnPrune struct

+ func NewColumnPrune(keep []string) *ColumnPrune

+ func (c *ColumnPrune) Clone() UnaryOperator

+ func (c *ColumnPrune) Close() error

+ func (c *ColumnPrune) Execute(_ context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (c *ColumnPrune) Init(_ context.Context) error

+ type CompareOp int

+ const OpEq

+ const OpGe

+ const OpGt

+ const OpIsNotNull

+ const OpIsNull

+ const OpLe

+ const OpLt

+ const OpNe

+ type DoneSignaler interface

+ Done func() bool

+ type DualSource struct

+ func (d *DualSource) Close() error

+ func (d *DualSource) Init(_ context.Context) error

+ func (d *DualSource) Next(_ context.Context) (*batch.RecordBatch, error)

+ type DynamicFilterEmitOp struct

+ func NewDynamicFilterEmitOp(filterID, keyColumn, keyType string, bloomBits int) *DynamicFilterEmitOp

+ func (op *DynamicFilterEmitOp) AddGuard(filterID, column string, probe GuardProbe)

+ func (op *DynamicFilterEmitOp) Close() error

+ func (op *DynamicFilterEmitOp) Execute(_ context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (op *DynamicFilterEmitOp) FilterID() string

+ func (op *DynamicFilterEmitOp) FinalizeGuards(ctx context.Context)

+ func (op *DynamicFilterEmitOp) GuardStats() (guards int, buffered, dropped int64, overflowed, unresolvable bool)

+ func (op *DynamicFilterEmitOp) Init(_ context.Context) error

+ func (op *DynamicFilterEmitOp) Snapshot() DynamicFilterPartial

+ type DynamicFilterPartial struct

+ Bloom []uint64

+ BloomBits int

+ BloomMask uint64

+ FilterID string

+ HasRange bool

+ KeyColumn string

+ KeyType string

+ Max int64

+ Min int64

+ RowCount int64

+ Unresolved bool

+ type DynamicRange struct

+ Column string

+ MaxValue any

+ MinValue any

+ type Expression func(b *batch.RecordBatch, row int) any

+ func ArithExpr(left, right Expression, op string) Expression

+ func ColumnRef(name string) Expression

+ func Literal(val any) Expression

+ type FatalEvalPanic interface

+ FatalEvalError func() error

+ type Filter struct

+ Pred Predicate

+ func NewFilter(pred Predicate) *Filter

+ func (f *Filter) Clone() UnaryOperator

+ func (f *Filter) Close() error

+ func (f *Filter) Execute(_ context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (f *Filter) Init(_ context.Context) error

+ type Float64Expression func(b *batch.RecordBatch, row int) (float64, bool)

+ type FlushableOperator interface

+ HasPendingFlush func() bool

+ NextFlush func(ctx context.Context) (*batch.RecordBatch, error)

+ type GuardProbe interface

+ Done func() bool

+ TryResolve func() (bloom []uint64, mask uint64, ok bool)

+ Wait func(ctx context.Context) (bloom []uint64, mask uint64, ok bool)

+ type HashAggregate struct

+ Aggs []AggColumn

+ GroupByAll bool

+ GroupByCols []string

+ GroupNDVHint int64

+ GroupingSets [][]int

+ InputRowHint int64

+ NullGroupCols []string

+ PartialDrainBytes int64

+ PartitionedDisjoint bool

+ Spill *memory.SpillManager

+ func NewHashAggregate(groupByCols []string, aggs []AggColumn) *HashAggregate

+ func (h *HashAggregate) CloneSink() SinkSource

+ func (h *HashAggregate) Close() error

+ func (h *HashAggregate) Consume(_ context.Context, b *batch.RecordBatch) error

+ func (h *HashAggregate) ConsumeHashed(ctx context.Context, b *batch.RecordBatch, hashes []uint64, plan *routePlan) error

+ func (h *HashAggregate) DrainOnHeapPressure(ctx context.Context) (bool, error)

+ func (h *HashAggregate) EstimateRelief(target int64) int64

+ func (h *HashAggregate) Finalize(_ context.Context) error

+ func (h *HashAggregate) GroupCeiling() int64

+ func (h *HashAggregate) IndexBornFlat() bool

+ func (h *HashAggregate) IndexConversions() int

+ func (h *HashAggregate) IndexFlatReason() string

+ func (h *HashAggregate) Init(_ context.Context) error

+ func (h *HashAggregate) InputRowBound() int64

+ func (h *HashAggregate) Inspect() memory.OperatorFootprint

+ func (h *HashAggregate) MergeSink(other SinkSource)

+ func (h *HashAggregate) Next(ctx context.Context) (*batch.RecordBatch, error)

+ func (h *HashAggregate) PartitionSelectors(b *batch.RecordBatch, parts int, sc *partitionScratch) *routedBatch

+ func (h *HashAggregate) SetEpochByteCap(cap int64)

+ func (h *HashAggregate) SetInputRowBound(rows int64)

+ func (h *HashAggregate) SpillSome(target int64) (int64, error)

+ func (h *HashAggregate) StateBytes() int64

+ type HashJoin struct

+ BuildColOrigins map[string]string

+ BuildRowHint int64

+ BuildSchemaHint []parquet.Column

+ BuildStoreCols []string

+ BuildTableAlias string

+ JoinType JoinType

+ LeftKeys []string

+ MemTracker *memory.Tracker

+ ProbeSchemaHint []parquet.Column

+ QualifyAllBuildCols bool

+ Residual func(probe *batch.RecordBatch, probeRow int, build *batch.RecordBatch, buildRow int) bool

+ RightKeys []string

+ SemiAntiFilter func(probe *batch.RecordBatch, probeRow int, build *batch.RecordBatch, buildRow int) bool

+ SemiAntiKeyOnly bool

+ SemiAntiNEBuildCol string

+ SemiAntiNEProbeCol string

+ Spill *memory.SpillManager

+ func NewHashJoin(joinType JoinType, leftKeys, rightKeys []string) *HashJoin

+ func (h *HashJoin) BloomPushdownOp() *BloomFilterOp

+ func (h *HashJoin) Build(ctx context.Context, source Source) error

+ func (h *HashJoin) BuildFromRows(schema []parquet.Column, rows []map[string]any)

+ func (h *HashJoin) BuildKeyRange() []DynamicRange

+ func (h *HashJoin) BuildRows() int64

+ func (h *HashJoin) Close() error

+ func (h *HashJoin) EstimateRelief(target int64) int64

+ func (h *HashJoin) FixKeyAssignment() bool

+ func (h *HashJoin) Inspect() memory.OperatorFootprint

+ func (h *HashJoin) NEActive() bool

+ func (h *HashJoin) Probe() *HashJoinProbe

+ func (h *HashJoin) PruneBuildColumns(keepCols []string)

+ func (h *HashJoin) SpillSome(target int64) (int64, error)

+ func (h *HashJoin) SpillState() *spillState

+ func (h *HashJoin) TrackedMem() int64

+ type HashJoinProbe struct

+ LateMaterialize bool

+ OutputFilter map[string]bool

+ func (p *HashJoinProbe) AcceptsViews() bool

+ func (p *HashJoinProbe) Clone() UnaryOperator

+ func (p *HashJoinProbe) Close() error

+ func (p *HashJoinProbe) EnableBoundedOutput()

+ func (p *HashJoinProbe) Execute(ctx context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (p *HashJoinProbe) FlushAntiMatched() *batch.RecordBatch

+ func (p *HashJoinProbe) FlushMatched() *batch.RecordBatch

+ func (p *HashJoinProbe) FlushUnmatched(leftSchema []parquet.Column) *batch.RecordBatch

+ func (p *HashJoinProbe) FlushUnmatchedRows() *batch.RecordBatch

+ func (p *HashJoinProbe) HasPendingFlush() bool

+ func (p *HashJoinProbe) HasPendingOutput() bool

+ func (p *HashJoinProbe) Init(_ context.Context) error

+ func (p *HashJoinProbe) NextFlush(ctx context.Context) (*batch.RecordBatch, error)

+ func (p *HashJoinProbe) NextOutput(ctx context.Context) (*batch.RecordBatch, error)

+ type HeldStateSource interface

+ ServesHeldState func() bool

+ type InFilter struct

+ ColName string

+ Negate bool

+ Values []any

+ func NewInFilter(colName string, values []any, negate bool) *InFilter

+ func (f *InFilter) Clone() UnaryOperator

+ func (f *InFilter) Close() error

+ func (f *InFilter) Execute(_ context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (f *InFilter) Init(_ context.Context) error

+ type Int64Expression func(b *batch.RecordBatch, row int) (int64, bool)

+ type JoinType int

+ const AntiJoin

+ const CrossJoin

+ const FullOuterJoin

+ const InnerJoin

+ const LeftJoin

+ const RightAntiJoin

+ const RightJoin

+ const RightSemiJoin

+ const SemiJoin

+ type KernelFilter struct

+ ColName string

+ Op CompareOp

+ RowFallback Predicate

+ Value any

+ func NewKernelFilter(colName string, op CompareOp, value any) *KernelFilter

+ func (f *KernelFilter) Clone() UnaryOperator

+ func (f *KernelFilter) Close() error

+ func (f *KernelFilter) Execute(ctx context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (f *KernelFilter) Init(_ context.Context) error

+ type LikeFilter struct

+ ColName string

+ Negate bool

+ Pattern string

+ func NewLikeFilter(colName, pattern string, negate bool) *LikeFilter

+ func (f *LikeFilter) Clone() UnaryOperator

+ func (f *LikeFilter) Close() error

+ func (f *LikeFilter) Execute(_ context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (f *LikeFilter) Init(_ context.Context) error

+ type Limit struct

+ Max int64

+ Offset int64

+ func NewLimit(n, offset int64) *Limit

+ func (l *Limit) AcceptsViews() bool

+ func (l *Limit) Clone() UnaryOperator

+ func (l *Limit) Close() error

+ func (l *Limit) Done() bool

+ func (l *Limit) Execute(_ context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (l *Limit) Init(_ context.Context) error

+ type MergeableSink interface

+ CloneSink func() SinkSource

+ MergeSink func(other SinkSource)

+ type NullCheckFilter struct

+ CheckNull bool

+ ColName string

+ func NewNullCheckFilter(colName string, checkNull bool) *NullCheckFilter

+ func (f *NullCheckFilter) Clone() UnaryOperator

+ func (f *NullCheckFilter) Close() error

+ func (f *NullCheckFilter) Execute(_ context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (f *NullCheckFilter) Init(_ context.Context) error

+ type OrFilter struct

+ Left UnaryOperator

+ Right UnaryOperator

+ func NewOrFilter(left, right UnaryOperator) *OrFilter

+ func (f *OrFilter) Clone() UnaryOperator

+ func (f *OrFilter) Close() error

+ func (f *OrFilter) Execute(ctx context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (f *OrFilter) Init(ctx context.Context) error

+ type OutputSharingAware interface

+ EnableSharedOutputs func()

+ type Pipeline struct

+ Ops []UnaryOperator

+ Sink Sink

+ Source Source

+ Workers int

+ func (p *Pipeline) Close() error

+ func (p *Pipeline) Run(ctx context.Context) (err error)

+ type Predicate func(b *batch.RecordBatch, row int) bool

+ func And(preds ...Predicate) Predicate

+ func ColumnCompare(colName string, op CompareOp, value any) Predicate

+ func ColumnLike(colName, pattern string, not bool) Predicate

+ func Or(preds ...Predicate) Predicate

+ type PressureDrainer interface

+ DrainOnHeapPressure func(ctx context.Context) (handled bool, err error)

+ type ProfileCollector struct

+ func NewProfileCollector() *ProfileCollector

+ func WrapPipeline(pipeline *Pipeline) *ProfileCollector

+ func (c *ProfileCollector) Add(name string) *ProfileStats

+ func (c *ProfileCollector) Stats() []*ProfileStats

+ type ProfileStats struct

+ Calls int64

+ Name string

+ RowsIn int64

+ RowsOut int64

+ WallTime time.Duration

+ type ProfiledOperator struct

+ func WrapOperator(op UnaryOperator, collector *ProfileCollector, name string) *ProfiledOperator

+ func (p *ProfiledOperator) Clone() UnaryOperator

+ func (p *ProfiledOperator) Close() error

+ func (p *ProfiledOperator) Done() bool

+ func (p *ProfiledOperator) EnableBoundedOutput()

+ func (p *ProfiledOperator) Execute(ctx context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (p *ProfiledOperator) HasPendingOutput() bool

+ func (p *ProfiledOperator) Init(ctx context.Context) error

+ func (p *ProfiledOperator) Inner() UnaryOperator

+ func (p *ProfiledOperator) NextOutput(ctx context.Context) (*batch.RecordBatch, error)

+ type ProfiledSink struct

+ func WrapSink(sink Sink, collector *ProfileCollector, name string) *ProfiledSink

+ func (p *ProfiledSink) Close() error

+ func (p *ProfiledSink) Consume(ctx context.Context, b *batch.RecordBatch) error

+ func (p *ProfiledSink) Finalize(ctx context.Context) error

+ func (p *ProfiledSink) Init(ctx context.Context) error

+ func (p *ProfiledSink) Inner() Sink

+ type ProfiledSource struct

+ func WrapSource(src Source, collector *ProfileCollector, name string) *ProfiledSource

+ func (p *ProfiledSource) Close() error

+ func (p *ProfiledSource) Init(ctx context.Context) error

+ func (p *ProfiledSource) Inner() Source

+ func (p *ProfiledSource) Next(ctx context.Context) (*batch.RecordBatch, error)

+ type ProgressReporter interface

+ AddBytes func(int64)

+ AddRows func(int64)

+ func ProgressReporterFromContext(ctx context.Context) ProgressReporter

+ type Project struct

+ Projections []ProjectColumn

+ func NewProject(projections []ProjectColumn) *Project

+ func (p *Project) Clone() UnaryOperator

+ func (p *Project) Close() error

+ func (p *Project) Execute(_ context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (p *Project) Init(_ context.Context) error

+ type ProjectColumn struct

+ Computed bool

+ Dimension int

+ DirectCopy string

+ Expr Expression

+ Float64Eval Float64Expression

+ Int64Eval Int64Expression

+ Name string

+ SourceCol string

+ Type parquet.TypeID

+ VecEval VecExpression

+ VecFloat64Clone func() VecFloat64Expression

+ VecFloat64Eval VecFloat64Expression

+ type ScanStatsProvider interface

+ RowsScanned func() int64

+ type SetOpEmit struct

+ func NewSetOpEmit(op string, all bool, leftCol, rightCol string) (*SetOpEmit, error)

+ func (s *SetOpEmit) Clone() UnaryOperator

+ func (s *SetOpEmit) Close() error

+ func (s *SetOpEmit) Execute(_ context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ func (s *SetOpEmit) Init(_ context.Context) error

+ type Sink interface

+ Close func() error

+ Consume func(ctx context.Context, b *batch.RecordBatch) error

+ Finalize func(ctx context.Context) error

+ Init func(ctx context.Context) error

+ type SinkSource interface

+ type SliceSource struct

+ func NewSliceSource(schema []Column, rows []map[string]any) *SliceSource

+ func (s *SliceSource) Close() error

+ func (s *SliceSource) Init(_ context.Context) error

+ func (s *SliceSource) Next(_ context.Context) (*batch.RecordBatch, error)

+ type Sort struct

+ Keys []SortKey

+ Limit int

+ Spill *memory.SpillManager

+ func NewSort(keys []SortKey) *Sort

+ func (s *Sort) CloneSink() SinkSource

+ func (s *Sort) Close() error

+ func (s *Sort) Consume(_ context.Context, b *batch.RecordBatch) error

+ func (s *Sort) DrainOnHeapPressure(ctx context.Context) (bool, error)

+ func (s *Sort) EstimateRelief(target int64) int64

+ func (s *Sort) Finalize(_ context.Context) error

+ func (s *Sort) Init(_ context.Context) error

+ func (s *Sort) Inspect() memory.OperatorFootprint

+ func (s *Sort) MergeSink(other SinkSource)

+ func (s *Sort) Next(_ context.Context) (*batch.RecordBatch, error)

+ func (s *Sort) SpillSome(_ int64) (int64, error)

+ func (s *Sort) Truncate(n int)

+ type SortKey struct

+ Column string

+ NullsLast bool

+ Order SortOrder

+ type SortMergeJoin struct

+ BuildColOrigins map[string]string

+ BuildTableAlias string

+ JoinType JoinType

+ LeftKeys []string

+ OutputFilter map[string]bool

+ QualifyAllBuildCols bool

+ RightKeys []string

+ Spill *memory.SpillManager

+ func NewSortMergeJoin(leftKeys, rightKeys []string) *SortMergeJoin

+ func (j *SortMergeJoin) Build(ctx context.Context, source Source) error

+ func (j *SortMergeJoin) Close() error

+ func (j *SortMergeJoin) Consume(_ context.Context, b *batch.RecordBatch) error

+ func (j *SortMergeJoin) EstimateRelief(target int64) int64

+ func (j *SortMergeJoin) Finalize(_ context.Context) error

+ func (j *SortMergeJoin) Init(_ context.Context) error

+ func (j *SortMergeJoin) Inspect() memory.OperatorFootprint

+ func (j *SortMergeJoin) Next(_ context.Context) (*batch.RecordBatch, error)

+ func (j *SortMergeJoin) SpillSome(target int64) (int64, error)

+ type SortOrder int

+ const Ascending

+ const Descending

+ type Source interface

+ Close func() error

+ Init func(ctx context.Context) error

+ Next func(ctx context.Context) (*batch.RecordBatch, error)

+ type SpillableBatchCollector struct

+ Spill *memory.SpillManager

+ func (c *SpillableBatchCollector) Close() error

+ func (c *SpillableBatchCollector) Consume(_ context.Context, b *batch.RecordBatch) error

+ func (c *SpillableBatchCollector) Finalize(_ context.Context) error

+ func (c *SpillableBatchCollector) Init(_ context.Context) error

+ func (c *SpillableBatchCollector) Iterate(fn func(*batch.RecordBatch) error) error

+ func (c *SpillableBatchCollector) NewReplaySource() *CollectorReplaySource

+ func (c *SpillableBatchCollector) NextReplay(_ context.Context) (*batch.RecordBatch, error)

+ func (c *SpillableBatchCollector) Release()

+ func (c *SpillableBatchCollector) Rows() int

+ func (c *SpillableBatchCollector) Schema() []parquet.Column

+ type TopN struct

+ Keys []SortKey

+ N int

+ func NewTopN(keys []SortKey, n int) *TopN

+ func (t *TopN) Close() error

+ func (t *TopN) Consume(ctx context.Context, b *batch.RecordBatch) error

+ func (t *TopN) Finalize(ctx context.Context) error

+ func (t *TopN) Init(ctx context.Context) error

+ func (t *TopN) InnerSort() *Sort

+ func (t *TopN) Next(ctx context.Context) (*batch.RecordBatch, error)

+ type UnaryOperator interface

+ Close func() error

+ Execute func(ctx context.Context, in *batch.RecordBatch) (*batch.RecordBatch, error)

+ Init func(ctx context.Context) error

+ type VecExpression func(b *batch.RecordBatch, out *batch.Vector, n int)

+ type VecFloat64Expression func(b *batch.RecordBatch, dst []float64, n int) bool

+ type ViewAware interface

+ AcceptsViews func() bool

+ type Window struct

+ Columns []WindowColumn

+ Spill *memory.SpillManager

+ func NewWindow(cols []WindowColumn) *Window

+ func (w *Window) Close() error

+ func (w *Window) Consume(_ context.Context, b *batch.RecordBatch) error

+ func (w *Window) DrainOnHeapPressure(ctx context.Context) (bool, error)

+ func (w *Window) EstimateRelief(target int64) int64

+ func (w *Window) Finalize(_ context.Context) error

+ func (w *Window) Init(_ context.Context) error

+ func (w *Window) Inspect() memory.OperatorFootprint

+ func (w *Window) Next(_ context.Context) (*batch.RecordBatch, error)

+ func (w *Window) SpillSome(_ int64) (int64, error)

+ type WindowBound struct

+ Offset int

+ Type string

+ type WindowColumn struct

+ Frame *WindowFrameSpec

+ Func WindowFunc

+ InputCol string

+ LagLeadDefault any

+ LagLeadOffset int

+ NthValueN int

+ NtileBuckets int

+ OrderBy []SortKey

+ OutputCol string

+ OutputType parquet.TypeID

+ PartitionBy []string

+ type WindowFrameSpec struct

+ End WindowBound

+ Mode string

+ Start WindowBound

+ type WindowFunc int

+ const WinAvg

+ const WinCount

+ const WinCumeDist

+ const WinDenseRank

+ const WinFirstValue

+ const WinLag

+ const WinLastValue

+ const WinLead

+ const WinMax

+ const WinMin

+ const WinNthValue

+ const WinNtile

+ const WinPercentRank

+ const WinRank

+ const WinRowNumber

+ const WinSum

+ func ParseWindowFunc(s string) (WindowFunc, bool)