package logicalplan

Import Path
	github.com/polarsignals/frostdb/query/logicalplan (on go.dev)

Dependency Relation
	imports 12 packages, and imported by 6 packages

Involved Source Files

	    builder.go
	    expr.go
	    logicalplan.go
	    optimize.go
	    validate.go
Package-Level Type Names (total 42)

	/* sort by: alphabet | popularity */
	 type AggFunc uint32 (basic type)

		Methods (only one)
			( AggFunc) String() string
		Implements (at least 2)
			 AggFunc : expvar.Var
			 AggFunc : fmt.Stringer
		As Types Of (total 8)
			const AggFuncAnd
			const AggFuncAvg
			const AggFuncCount
			const AggFuncMax
			const AggFuncMin
			const AggFuncSum
			const AggFuncUnique
			const AggFuncUnknown

	 type AggFuncPushDown (struct)
		AggFuncPushDown optimizer tries to push down an aggregation function operator
		to the table provider. This can be done in the case of some aggregation
		functions on global aggregations (i.e. no group by) without filters.
		The storage engine can make smarter decisions than just returning all the
		data, such as in the case of max functions, memoizing the max value seen
		so far and only scanning row groups that contain a value greater than the
		memoized value. It modifies the plan in place.

		Methods (only one)
			(*AggFuncPushDown) Optimize(plan *LogicalPlan) *LogicalPlan
		Implements (at least one exported)
			*AggFuncPushDown : Optimizer

	 type Aggregation (struct)

		Fields (total 2)
			AggExprs []*AggregationFunction
			GroupExprs []Expr
		Methods (only one)
			(*Aggregation) String() string
		Implements (at least 2)
			*Aggregation : expvar.Var
			*Aggregation : fmt.Stringer
		As Inputs Of (at least one exported)
			func github.com/polarsignals/frostdb/query/physicalplan.Aggregate(pool memory.Allocator, tracer trace.Tracer, agg *Aggregation, final bool, ordered bool, seed maphash.Seed) (physicalplan.PhysicalPlan, error)

	 type AggregationFunction (struct)

		Fields (total 2)
			Expr Expr
			Func AggFunc
		Methods (total 11)
			(*AggregationFunction) Accept(visitor Visitor) bool
			(*AggregationFunction) Alias(alias string) *AliasExpr
			(*AggregationFunction) Clone() Expr
			(*AggregationFunction) ColumnsUsedExprs() []Expr
			(*AggregationFunction) Computed() bool
			(*AggregationFunction) DataType(l ExprTypeFinder) (arrow.DataType, error)
			(*AggregationFunction) Equal(other Expr) bool
			(*AggregationFunction) MatchColumn(columnName string) bool
			(*AggregationFunction) MatchPath(path string) bool
			(*AggregationFunction) Name() string
			(*AggregationFunction) String() string
		Implements (at least 4)
			*AggregationFunction : Expr
			*AggregationFunction : Named
			*AggregationFunction : expvar.Var
			*AggregationFunction : fmt.Stringer
		As Outputs Of (at least 7)
			func AndAgg(expr Expr) *AggregationFunction
			func Avg(expr Expr) *AggregationFunction
			func Count(expr Expr) *AggregationFunction
			func Max(expr Expr) *AggregationFunction
			func Min(expr Expr) *AggregationFunction
			func Sum(expr Expr) *AggregationFunction
			func Unique(expr Expr) *AggregationFunction
		As Inputs Of (at least one exported)
			func Builder.Aggregate(aggExpr []*AggregationFunction, groupExprs []Expr) Builder

	 type AliasExpr (struct)

		Fields (total 2)
			Alias string
			Expr Expr
		Methods (total 10)
			(*AliasExpr) Accept(visitor Visitor) bool
			(*AliasExpr) Clone() Expr
			(*AliasExpr) ColumnsUsedExprs() []Expr
			(*AliasExpr) Computed() bool
			(*AliasExpr) DataType(l ExprTypeFinder) (arrow.DataType, error)
			(*AliasExpr) Equal(other Expr) bool
			(*AliasExpr) MatchColumn(columnName string) bool
			(*AliasExpr) MatchPath(path string) bool
			(*AliasExpr) Name() string
			(*AliasExpr) String() string
		Implements (at least 4)
			*AliasExpr : Expr
			*AliasExpr : Named
			*AliasExpr : expvar.Var
			*AliasExpr : fmt.Stringer
		As Outputs Of (at least 5)
			func (*AggregationFunction).Alias(alias string) *AliasExpr
			func (*BinaryExpr).Alias(alias string) *AliasExpr
			func (*Column).Alias(alias string) *AliasExpr
			func (*ConvertExpr).Alias(alias string) *AliasExpr
			func (*IfExpr).Alias(name string) *AliasExpr

	 type AllExpr (struct)

		Methods (total 10)
			(*AllExpr) Accept(visitor Visitor) bool
			(*AllExpr) Clone() Expr
			(*AllExpr) ColumnsUsedExprs() []Expr
			(*AllExpr) Computed() bool
			(*AllExpr) DataType(ExprTypeFinder) (arrow.DataType, error)
			(*AllExpr) Equal(other Expr) bool
			(*AllExpr) MatchColumn(_ string) bool
			(*AllExpr) MatchPath(_ string) bool
			(*AllExpr) Name() string
			(*AllExpr) String() string
		Implements (at least 4)
			*AllExpr : Expr
			*AllExpr : Named
			*AllExpr : expvar.Var
			*AllExpr : fmt.Stringer
		As Outputs Of (at least one exported)
			func All() *AllExpr

	 type BinaryExpr (struct)

		Fields (total 3)
			Left Expr
			Op Op
			Right Expr
		Methods (total 11)
			(*BinaryExpr) Accept(visitor Visitor) bool
			(*BinaryExpr) Alias(alias string) *AliasExpr
			(*BinaryExpr) Clone() Expr
			(*BinaryExpr) ColumnsUsedExprs() []Expr
			(*BinaryExpr) Computed() bool
			(*BinaryExpr) DataType(l ExprTypeFinder) (arrow.DataType, error)
			(*BinaryExpr) Equal(other Expr) bool
			(*BinaryExpr) MatchColumn(columnName string) bool
			(*BinaryExpr) MatchPath(path string) bool
			(*BinaryExpr) Name() string
			(*BinaryExpr) String() string
		Implements (at least 4)
			*BinaryExpr : Expr
			*BinaryExpr : Named
			*BinaryExpr : expvar.Var
			*BinaryExpr : fmt.Stringer
		As Outputs Of (at least 14)
			func Add(left, right Expr) *BinaryExpr
			func Div(left, right Expr) *BinaryExpr
			func Mul(left, right Expr) *BinaryExpr
			func Sub(left, right Expr) *BinaryExpr
			func (*Column).Contains(pattern string) *BinaryExpr
			func (*Column).ContainsNot(pattern string) *BinaryExpr
			func (*Column).Eq(e Expr) *BinaryExpr
			func (*Column).Gt(e Expr) *BinaryExpr
			func (*Column).GtEq(e Expr) *BinaryExpr
			func (*Column).Lt(e Expr) *BinaryExpr
			func (*Column).LtEq(e Expr) *BinaryExpr
			func (*Column).NotEq(e Expr) *BinaryExpr
			func (*Column).RegexMatch(pattern string) *BinaryExpr
			func (*Column).RegexNotMatch(pattern string) *BinaryExpr
		As Inputs Of (at least 2)
			func ValidateFilterAndBinaryExpr(plan *LogicalPlan, expr *BinaryExpr) *ExprValidationError
			func ValidateFilterBinaryExpr(plan *LogicalPlan, expr *BinaryExpr) *ExprValidationError

	 type Builder (struct)

		Methods (total 9)
			( Builder) Aggregate(aggExpr []*AggregationFunction, groupExprs []Expr) Builder
			( Builder) Build() (*LogicalPlan, error)
			( Builder) Distinct(exprs ...Expr) Builder
			( Builder) Filter(expr Expr) Builder
			( Builder) Limit(expr Expr) Builder
			( Builder) Project(exprs ...Expr) Builder
			( Builder) Sample(expr, limit Expr) Builder
			( Builder) Scan(provider TableProvider, tableName string) Builder
			( Builder) ScanSchema(provider TableProvider, tableName string) Builder
		As Outputs Of (at least 8)
			func Builder.Aggregate(aggExpr []*AggregationFunction, groupExprs []Expr) Builder
			func Builder.Distinct(exprs ...Expr) Builder
			func Builder.Filter(expr Expr) Builder
			func Builder.Limit(expr Expr) Builder
			func Builder.Project(exprs ...Expr) Builder
			func Builder.Sample(expr, limit Expr) Builder
			func Builder.Scan(provider TableProvider, tableName string) Builder
			func Builder.ScanSchema(provider TableProvider, tableName string) Builder

	 type Callback (func)
		Callback is a function that is called throughout a chain of operators
		modifying the underlying data.

		As Inputs Of (at least 4)
			func TableReader.Iterator(ctx context.Context, tx uint64, pool memory.Allocator, callbacks []Callback, options ...Option) error
			func TableReader.SchemaIterator(ctx context.Context, tx uint64, pool memory.Allocator, callbacks []Callback, options ...Option) error
			func github.com/polarsignals/frostdb.(*Table).Iterator(ctx context.Context, tx uint64, pool memory.Allocator, callbacks []Callback, options ...Option) error
			func github.com/polarsignals/frostdb.(*Table).SchemaIterator(ctx context.Context, tx uint64, pool memory.Allocator, callbacks []Callback, options ...Option) error

	 type Column (struct)

		Fields (only one)
			ColumnName string
		Methods (total 21)
			(*Column) Accept(visitor Visitor) bool
			(*Column) Alias(alias string) *AliasExpr
			(*Column) Clone() Expr
			(*Column) ColumnsUsedExprs() []Expr
			(*Column) Computed() bool
			(*Column) Contains(pattern string) *BinaryExpr
			(*Column) ContainsNot(pattern string) *BinaryExpr
			(*Column) DataType(l ExprTypeFinder) (arrow.DataType, error)
			(*Column) Eq(e Expr) *BinaryExpr
			(*Column) Equal(other Expr) bool
			(*Column) Gt(e Expr) *BinaryExpr
			(*Column) GtEq(e Expr) *BinaryExpr
			(*Column) Lt(e Expr) *BinaryExpr
			(*Column) LtEq(e Expr) *BinaryExpr
			(*Column) MatchColumn(columnName string) bool
			(*Column) MatchPath(path string) bool
			(*Column) Name() string
			(*Column) NotEq(e Expr) *BinaryExpr
			(*Column) RegexMatch(pattern string) *BinaryExpr
			(*Column) RegexNotMatch(pattern string) *BinaryExpr
			(*Column) String() string
		Implements (at least 4)
			*Column : Expr
			*Column : Named
			*Column : expvar.Var
			*Column : fmt.Stringer
		As Outputs Of (at least one exported)
			func Col(name string) *Column

	 type ConvertExpr (struct)

		Fields (total 2)
			Expr Expr
			Type arrow.DataType
		Methods (total 11)
			(*ConvertExpr) Accept(visitor Visitor) bool
			(*ConvertExpr) Alias(alias string) *AliasExpr
			(*ConvertExpr) Clone() Expr
			(*ConvertExpr) ColumnsUsedExprs() []Expr
			(*ConvertExpr) Computed() bool
			(*ConvertExpr) DataType(l ExprTypeFinder) (arrow.DataType, error)
			(*ConvertExpr) Equal(other Expr) bool
			(*ConvertExpr) MatchColumn(columnName string) bool
			(*ConvertExpr) MatchPath(path string) bool
			(*ConvertExpr) Name() string
			(*ConvertExpr) String() string
		Implements (at least 4)
			*ConvertExpr : Expr
			*ConvertExpr : Named
			*ConvertExpr : expvar.Var
			*ConvertExpr : fmt.Stringer
		As Outputs Of (at least one exported)
			func Convert(e Expr, t arrow.DataType) *ConvertExpr

	 type Distinct (struct)

		Fields (only one)
			Exprs []Expr
		Methods (only one)
			(*Distinct) String() string
		Implements (at least 2)
			*Distinct : expvar.Var
			*Distinct : fmt.Stringer

	 type DistinctPushDown (struct)
		DistinctPushDown optimizer tries to push down the distinct operator to
		the table provider. There are certain cases of distinct queries where the
		storage engine can make smarter decisions than just returning all the data,
		such as with dictionary encoded columns that are not filtered they can
		return only the dictionary avoiding unnecessary decoding and deduplication
		in downstream distinct operators. It modifies the plan in place.

		Methods (only one)
			(*DistinctPushDown) Optimize(plan *LogicalPlan) *LogicalPlan
		Implements (at least one exported)
			*DistinctPushDown : Optimizer

	 type DurationExpr (struct)

		Methods (total 11)
			(*DurationExpr) Accept(visitor Visitor) bool
			(*DurationExpr) Clone() Expr
			(*DurationExpr) ColumnsUsedExprs() []Expr
			(*DurationExpr) Computed() bool
			(*DurationExpr) DataType(_ ExprTypeFinder) (arrow.DataType, error)
			(*DurationExpr) Equal(other Expr) bool
			(*DurationExpr) MatchColumn(columnName string) bool
			(*DurationExpr) MatchPath(_ string) bool
			(*DurationExpr) Name() string
			(*DurationExpr) String() string
			(*DurationExpr) Value() time.Duration
		Implements (at least 4)
			*DurationExpr : Expr
			*DurationExpr : Named
			*DurationExpr : expvar.Var
			*DurationExpr : fmt.Stringer
		As Outputs Of (at least one exported)
			func Duration(d time.Duration) *DurationExpr

	 type DynamicColumn (struct)

		Fields (only one)
			ColumnName string
		Methods (total 10)
			(*DynamicColumn) Accept(visitor Visitor) bool
			(*DynamicColumn) Clone() Expr
			(*DynamicColumn) ColumnsUsedExprs() []Expr
			(*DynamicColumn) Computed() bool
			(*DynamicColumn) DataType(l ExprTypeFinder) (arrow.DataType, error)
			(*DynamicColumn) Equal(other Expr) bool
			(*DynamicColumn) MatchColumn(columnName string) bool
			(*DynamicColumn) MatchPath(path string) bool
			(*DynamicColumn) Name() string
			(*DynamicColumn) String() string
		Implements (at least 4)
			*DynamicColumn : Expr
			*DynamicColumn : Named
			*DynamicColumn : expvar.Var
			*DynamicColumn : fmt.Stringer
		As Outputs Of (at least one exported)
			func DynCol(name string) *DynamicColumn

	 type Expr (interface)

		Methods (total 10)
			( Expr) Accept(Visitor) bool
			( Expr) Clone() Expr
				Clone returns a deep copy of the expression.

			( Expr) ColumnsUsedExprs() []Expr
				ColumnsUsedExprs extracts all the expressions that are used that cause
				physical data to be read from a column.

			( Expr) Computed() bool
				Computed returns whether the expression is computed as opposed to being
				a static value or unmodified physical column.

			( Expr) DataType(ExprTypeFinder) (arrow.DataType, error)
			( Expr) Equal(Expr) bool
			( Expr) MatchColumn(columnName string) bool
				MatchColumn returns whether it would operate on the passed column. In
				contrast to the ColumnUsedExprs function from the Expr interface, it is not
				useful to identify which columns are to be read physically. This is
				necessary to distinguish between projections.
				
				Take the example of a column that projects `XYZ > 0`. Matcher can be
				used to identify the column in the resulting Apache Arrow frames, while
				ColumnsUsed will return `XYZ` to be necessary to be loaded physically.

			( Expr) MatchPath(path string) bool
				MatchPath returns whether it would operate on the passed path. This is nessesary for nested schemas.

			( Expr) Name() string
			( Expr) String() string
		Implemented By (at least 12)
			*AggregationFunction
			*AliasExpr
			*AllExpr
			*BinaryExpr
			*Column
			*ConvertExpr
			*DurationExpr
			*DynamicColumn
			*IfExpr
			*IsNullExpr
			*LiteralExpr
			*NotExpr
		Implements (at least 3)
			 Expr : Named
			 Expr : expvar.Var
			 Expr : fmt.Stringer
		As Outputs Of (at least 29)
			func And(exprs ...Expr) Expr
			func Cols(names ...string) []Expr
			func Or(exprs ...Expr) Expr
			func (*AggregationFunction).Clone() Expr
			func (*AggregationFunction).ColumnsUsedExprs() []Expr
			func (*AliasExpr).Clone() Expr
			func (*AliasExpr).ColumnsUsedExprs() []Expr
			func (*AllExpr).Clone() Expr
			func (*AllExpr).ColumnsUsedExprs() []Expr
			func (*BinaryExpr).Clone() Expr
			func (*BinaryExpr).ColumnsUsedExprs() []Expr
			func (*Column).Clone() Expr
			func (*Column).ColumnsUsedExprs() []Expr
			func (*ConvertExpr).Clone() Expr
			func (*ConvertExpr).ColumnsUsedExprs() []Expr
			func (*DurationExpr).Clone() Expr
			func (*DurationExpr).ColumnsUsedExprs() []Expr
			func (*DynamicColumn).Clone() Expr
			func (*DynamicColumn).ColumnsUsedExprs() []Expr
			func Expr.Clone() Expr
			func Expr.ColumnsUsedExprs() []Expr
			func (*IfExpr).Clone() Expr
			func (*IfExpr).ColumnsUsedExprs() []Expr
			func (*IsNullExpr).Clone() Expr
			func (*IsNullExpr).ColumnsUsedExprs() []Expr
			func (*LiteralExpr).Clone() Expr
			func (*LiteralExpr).ColumnsUsedExprs() []Expr
			func (*NotExpr).Clone() Expr
			func (*NotExpr).ColumnsUsedExprs() []Expr
		As Inputs Of (at least 79)
			func Add(left, right Expr) *BinaryExpr
			func And(exprs ...Expr) Expr
			func AndAgg(expr Expr) *AggregationFunction
			func Avg(expr Expr) *AggregationFunction
			func Convert(e Expr, t arrow.DataType) *ConvertExpr
			func Count(expr Expr) *AggregationFunction
			func DataTypeForExprWithSchema(expr Expr, s *dynparquet.Schema) (arrow.DataType, error)
			func Div(left, right Expr) *BinaryExpr
			func If(cond, then, els Expr) *IfExpr
			func IsNull(expr Expr) *IsNullExpr
			func Max(expr Expr) *AggregationFunction
			func Min(expr Expr) *AggregationFunction
			func Mul(left, right Expr) *BinaryExpr
			func Not(expr Expr) *NotExpr
			func Or(exprs ...Expr) Expr
			func Sub(left, right Expr) *BinaryExpr
			func Sum(expr Expr) *AggregationFunction
			func Unique(expr Expr) *AggregationFunction
			func ValidateFilterExpr(plan *LogicalPlan, e Expr) *ExprValidationError
			func WithDistinctColumns(e ...Expr) Option
			func WithFilter(e Expr) Option
			func WithPhysicalProjection(e ...Expr) Option
			func WithProjection(e ...Expr) Option
			func (*AggregationFunction).Equal(other Expr) bool
			func (*AliasExpr).Equal(other Expr) bool
			func (*AllExpr).Equal(other Expr) bool
			func (*BinaryExpr).Equal(other Expr) bool
			func Builder.Aggregate(aggExpr []*AggregationFunction, groupExprs []Expr) Builder
			func Builder.Distinct(exprs ...Expr) Builder
			func Builder.Filter(expr Expr) Builder
			func Builder.Limit(expr Expr) Builder
			func Builder.Project(exprs ...Expr) Builder
			func Builder.Sample(expr, limit Expr) Builder
			func (*Column).Eq(e Expr) *BinaryExpr
			func (*Column).Equal(other Expr) bool
			func (*Column).Gt(e Expr) *BinaryExpr
			func (*Column).GtEq(e Expr) *BinaryExpr
			func (*Column).Lt(e Expr) *BinaryExpr
			func (*Column).LtEq(e Expr) *BinaryExpr
			func (*Column).NotEq(e Expr) *BinaryExpr
			func (*ConvertExpr).Equal(other Expr) bool
			func (*DurationExpr).Equal(other Expr) bool
			func (*DynamicColumn).Equal(other Expr) bool
			func Expr.Equal(Expr) bool
			func ExprTypeFinder.DataTypeForExpr(expr Expr) (arrow.DataType, error)
			func (*IfExpr).Equal(other Expr) bool
			func (*IsNullExpr).Equal(other Expr) bool
			func (*LiteralExpr).Equal(other Expr) bool
			func (*LogicalPlan).DataTypeForExpr(expr Expr) (arrow.DataType, error)
			func (*NotExpr).Equal(other Expr) bool
			func (*SchemaScan).DataTypeForExpr(expr Expr) (arrow.DataType, error)
			func (*TableScan).DataTypeForExpr(expr Expr) (arrow.DataType, error)
			func Visitor.PostVisit(expr Expr) bool
			func Visitor.PreVisit(expr Expr) bool
			func Visitor.Visit(expr Expr) bool
			func github.com/polarsignals/frostdb/query/expr.BooleanExpr(expr Expr) (expr.TrueNegativeFilter, error)
			func github.com/polarsignals/frostdb/query/expr.PreExprVisitorFunc.PostVisit(_ Expr) bool
			func github.com/polarsignals/frostdb/query/expr.PreExprVisitorFunc.PreVisit(expr Expr) bool
			func github.com/polarsignals/frostdb/query/expr.PreExprVisitorFunc.Visit(_ Expr) bool
			func github.com/polarsignals/frostdb/query/physicalplan.Distinct(pool memory.Allocator, tracer trace.Tracer, columns []Expr) *physicalplan.Distinction
			func github.com/polarsignals/frostdb/query/physicalplan.Filter(pool memory.Allocator, tracer trace.Tracer, filterExpr Expr) (*physicalplan.PredicateFilter, error)
			func github.com/polarsignals/frostdb/query/physicalplan.Limit(pool memory.Allocator, tracer trace.Tracer, expr Expr) (*physicalplan.Limiter, error)
			func github.com/polarsignals/frostdb/query/physicalplan.NewHashAggregate(pool memory.Allocator, tracer trace.Tracer, aggregations []physicalplan.Aggregation, groupByColumnMatchers []Expr, seed maphash.Seed, finalStage bool) *physicalplan.HashAggregate
			func github.com/polarsignals/frostdb/query/physicalplan.NewOrderedAggregate(pool memory.Allocator, tracer trace.Tracer, aggregation physicalplan.Aggregation, groupByColumnMatchers []Expr, finalStage bool) *physicalplan.OrderedAggregate
			func github.com/polarsignals/frostdb/query/physicalplan.NewOrderedSynchronizer(pool memory.Allocator, inputs int, orderByExprs []Expr) *physicalplan.OrderedSynchronizer
			func github.com/polarsignals/frostdb/query/physicalplan.Project(mem memory.Allocator, tracer trace.Tracer, exprs []Expr) (*physicalplan.Projection, error)
			func github.com/polarsignals/frostdb/query/physicalplan.PreExprVisitorFunc.PostVisit(_ Expr) bool
			func github.com/polarsignals/frostdb/query/physicalplan.PreExprVisitorFunc.PreVisit(expr Expr) bool
			func github.com/polarsignals/frostdb/query/physicalplan.PreExprVisitorFunc.Visit(_ Expr) bool
			func github.com/polarsignals/frostdb.DataSinkSource.Scan(ctx context.Context, prefix string, schema *dynparquet.Schema, filter Expr, lastBlockTimestamp uint64, callback func(context.Context, any) error) error
			func github.com/polarsignals/frostdb.DataSource.Scan(ctx context.Context, prefix string, schema *dynparquet.Schema, filter Expr, lastBlockTimestamp uint64, callback func(context.Context, any) error) error
			func github.com/polarsignals/frostdb.(*DefaultObjstoreBucket).Scan(ctx context.Context, prefix string, _ *dynparquet.Schema, filter Expr, lastBlockTimestamp uint64, callback func(context.Context, any) error) error
			func github.com/polarsignals/frostdb/index.(*LSM).Scan(ctx context.Context, _ string, _ *dynparquet.Schema, filter Expr, tx uint64, callback func(context.Context, any) error) error
			func github.com/polarsignals/frostdb/pqarrow.Project(r arrow.Record, projections []Expr) arrow.Record
			func github.com/polarsignals/frostdb/pqarrow.SingleMatchingColumn(distinctColumns []Expr, fields []parquet.Field) bool
			func github.com/polarsignals/frostdb/pqarrow.PreExprVisitorFunc.PostVisit(_ Expr) bool
			func github.com/polarsignals/frostdb/pqarrow.PreExprVisitorFunc.PreVisit(expr Expr) bool
			func github.com/polarsignals/frostdb/pqarrow.PreExprVisitorFunc.Visit(_ Expr) bool
			func github.com/polarsignals/frostdb/storage.(*Iceberg).Scan(ctx context.Context, prefix string, _ *dynparquet.Schema, filter Expr, _ uint64, callback func(context.Context, any) error) error

	 type ExprTypeFinder (interface)

		Methods (only one)
			( ExprTypeFinder) DataTypeForExpr(expr Expr) (arrow.DataType, error)
		Implemented By (at least 3)
			*LogicalPlan
			*SchemaScan
			*TableScan
		As Inputs Of (at least 13)
			func (*AggregationFunction).DataType(l ExprTypeFinder) (arrow.DataType, error)
			func (*AliasExpr).DataType(l ExprTypeFinder) (arrow.DataType, error)
			func (*AllExpr).DataType(ExprTypeFinder) (arrow.DataType, error)
			func (*BinaryExpr).DataType(l ExprTypeFinder) (arrow.DataType, error)
			func (*Column).DataType(l ExprTypeFinder) (arrow.DataType, error)
			func (*ConvertExpr).DataType(l ExprTypeFinder) (arrow.DataType, error)
			func (*DurationExpr).DataType(_ ExprTypeFinder) (arrow.DataType, error)
			func (*DynamicColumn).DataType(l ExprTypeFinder) (arrow.DataType, error)
			func Expr.DataType(ExprTypeFinder) (arrow.DataType, error)
			func (*IfExpr).DataType(l ExprTypeFinder) (arrow.DataType, error)
			func (*IsNullExpr).DataType(l ExprTypeFinder) (arrow.DataType, error)
			func (*LiteralExpr).DataType(_ ExprTypeFinder) (arrow.DataType, error)
			func (*NotExpr).DataType(l ExprTypeFinder) (arrow.DataType, error)

	 type ExprValidationError (struct)
		ExprValidationError is the error for an invalid expression that was found during validation.

		Methods (only one)
			(*ExprValidationError) Error() string
				ExprValidationError.Error prints the error message in a human-readable format.
				implements the error interface.

		Implements (at least one exported)
			*ExprValidationError : error
		As Outputs Of (at least 5)
			func ValidateAggregationExpr(plan *LogicalPlan) *ExprValidationError
			func ValidateComparingTypes(columnType *format.LogicalType, literal scalar.Scalar) *ExprValidationError
			func ValidateFilterAndBinaryExpr(plan *LogicalPlan, expr *BinaryExpr) *ExprValidationError
			func ValidateFilterBinaryExpr(plan *LogicalPlan, expr *BinaryExpr) *ExprValidationError
			func ValidateFilterExpr(plan *LogicalPlan, e Expr) *ExprValidationError

	 type Filter (struct)

		Fields (only one)
			Expr Expr
		Methods (only one)
			(*Filter) String() string
		Implements (at least 2)
			*Filter : expvar.Var
			*Filter : fmt.Stringer

	 type FilterPushDown (struct)
		FilterPushDown optimizer tries to push down the filters of a query down
		to the actual physical table scan. This allows the table provider to make
		smarter decisions about which pieces of data to load in the first place or
		which are definitely not useful to the query at all. It does not guarantee
		that all data will be filtered accordingly, it is just a mechanism to read
		less data from disk. It modifies the plan in place.

		Methods (only one)
			(*FilterPushDown) Optimize(plan *LogicalPlan) *LogicalPlan
		Implements (at least one exported)
			*FilterPushDown : Optimizer

	 type IfExpr (struct)

		Fields (total 3)
			Cond Expr
			Else Expr
			Then Expr
		Methods (total 11)
			(*IfExpr) Accept(visitor Visitor) bool
			(*IfExpr) Alias(name string) *AliasExpr
			(*IfExpr) Clone() Expr
			(*IfExpr) ColumnsUsedExprs() []Expr
			(*IfExpr) Computed() bool
			(*IfExpr) DataType(l ExprTypeFinder) (arrow.DataType, error)
			(*IfExpr) Equal(other Expr) bool
			(*IfExpr) MatchColumn(columnName string) bool
			(*IfExpr) MatchPath(path string) bool
			(*IfExpr) Name() string
			(*IfExpr) String() string
		Implements (at least 4)
			*IfExpr : Expr
			*IfExpr : Named
			*IfExpr : expvar.Var
			*IfExpr : fmt.Stringer
		As Outputs Of (at least one exported)
			func If(cond, then, els Expr) *IfExpr

	 type IsNullExpr (struct)

		Fields (only one)
			Expr Expr
		Methods (total 10)
			(*IsNullExpr) Accept(visitor Visitor) bool
			(*IsNullExpr) Clone() Expr
			(*IsNullExpr) ColumnsUsedExprs() []Expr
			(*IsNullExpr) Computed() bool
			(*IsNullExpr) DataType(l ExprTypeFinder) (arrow.DataType, error)
			(*IsNullExpr) Equal(other Expr) bool
			(*IsNullExpr) MatchColumn(columnName string) bool
			(*IsNullExpr) MatchPath(path string) bool
			(*IsNullExpr) Name() string
			(*IsNullExpr) String() string
		Implements (at least 4)
			*IsNullExpr : Expr
			*IsNullExpr : Named
			*IsNullExpr : expvar.Var
			*IsNullExpr : fmt.Stringer
		As Outputs Of (at least one exported)
			func IsNull(expr Expr) *IsNullExpr

	 type IterOptions (struct)
		IterOptions are a set of options for the TableReader Iterators.

		Fields (total 5)
			DistinctColumns []Expr
			Filter Expr
			PhysicalProjection []Expr
			Projection []Expr
			ReadMode ReadMode
		As Inputs Of (at least 3)
			func github.com/polarsignals/frostdb/pqarrow.NewParquetConverter(pool memory.Allocator, iterOpts IterOptions) *pqarrow.ParquetConverter
			func github.com/polarsignals/frostdb/pqarrow.ParquetRowGroupToArrowSchema(ctx context.Context, rg parquet.RowGroup, s *dynparquet.Schema, options IterOptions) (*arrow.Schema, error)
			func github.com/polarsignals/frostdb/pqarrow.ParquetSchemaToArrowSchema(ctx context.Context, schema *parquet.Schema, s *dynparquet.Schema, options IterOptions) (*arrow.Schema, error)

	 type Limit (struct)

		Fields (only one)
			Expr Expr
		Methods (only one)
			(*Limit) String() string
		Implements (at least 2)
			*Limit : expvar.Var
			*Limit : fmt.Stringer

	 type LiteralExpr (struct)

		Fields (only one)
			Value scalar.Scalar
		Methods (total 10)
			(*LiteralExpr) Accept(visitor Visitor) bool
			(*LiteralExpr) Clone() Expr
			(*LiteralExpr) ColumnsUsedExprs() []Expr
			(*LiteralExpr) Computed() bool
			(*LiteralExpr) DataType(_ ExprTypeFinder) (arrow.DataType, error)
			(*LiteralExpr) Equal(other Expr) bool
			(*LiteralExpr) MatchColumn(columnName string) bool
			(*LiteralExpr) MatchPath(path string) bool
			(*LiteralExpr) Name() string
			(*LiteralExpr) String() string
		Implements (at least 4)
			*LiteralExpr : Expr
			*LiteralExpr : Named
			*LiteralExpr : expvar.Var
			*LiteralExpr : fmt.Stringer
		As Outputs Of (at least one exported)
			func Literal(v interface{}) *LiteralExpr

	 type LogicalPlan (struct)
		LogicalPlan is a logical representation of a query. Each LogicalPlan is a
		sub-tree of the query. It is built recursively.

		Fields (total 9)
			Aggregation *Aggregation
			Distinct *Distinct
			Filter *Filter
			Input *LogicalPlan
			Limit *Limit
			Projection *Projection
			Sample *Sample
			SchemaScan *SchemaScan
				Each LogicalPlan struct must only have one of the following.

			TableScan *TableScan
		Methods (total 5)
			(*LogicalPlan) Accept(visitor PlanVisitor) bool
			(*LogicalPlan) DataTypeForExpr(expr Expr) (arrow.DataType, error)
			(*LogicalPlan) InputSchema() *dynparquet.Schema
				InputSchema returns the schema that the query will execute against.

			(*LogicalPlan) String() string
			(*LogicalPlan) TableReader() (TableReader, error)
				TableReader returns the table reader.

		Implements (at least 3)
			*LogicalPlan : ExprTypeFinder
			*LogicalPlan : expvar.Var
			*LogicalPlan : fmt.Stringer
		As Outputs Of (at least 6)
			func (*AggFuncPushDown).Optimize(plan *LogicalPlan) *LogicalPlan
			func Builder.Build() (*LogicalPlan, error)
			func (*DistinctPushDown).Optimize(plan *LogicalPlan) *LogicalPlan
			func (*FilterPushDown).Optimize(plan *LogicalPlan) *LogicalPlan
			func Optimizer.Optimize(plan *LogicalPlan) *LogicalPlan
			func (*PhysicalProjectionPushDown).Optimize(plan *LogicalPlan) *LogicalPlan
		As Inputs Of (at least 23)
			func Validate(plan *LogicalPlan) error
			func ValidateAggregation(plan *LogicalPlan) *PlanValidationError
			func ValidateAggregationExpr(plan *LogicalPlan) *ExprValidationError
			func ValidateFilter(plan *LogicalPlan) *PlanValidationError
			func ValidateFilterAndBinaryExpr(plan *LogicalPlan, expr *BinaryExpr) *ExprValidationError
			func ValidateFilterBinaryExpr(plan *LogicalPlan, expr *BinaryExpr) *ExprValidationError
			func ValidateFilterExpr(plan *LogicalPlan, e Expr) *ExprValidationError
			func ValidateInput(plan *LogicalPlan) *PlanValidationError
			func ValidateSchemaScan(plan *LogicalPlan) *PlanValidationError
			func ValidateSingleFieldSet(plan *LogicalPlan) *PlanValidationError
			func ValidateTableScan(plan *LogicalPlan) *PlanValidationError
			func (*AggFuncPushDown).Optimize(plan *LogicalPlan) *LogicalPlan
			func (*DistinctPushDown).Optimize(plan *LogicalPlan) *LogicalPlan
			func (*FilterPushDown).Optimize(plan *LogicalPlan) *LogicalPlan
			func Optimizer.Optimize(plan *LogicalPlan) *LogicalPlan
			func (*PhysicalProjectionPushDown).Optimize(plan *LogicalPlan) *LogicalPlan
			func PlanVisitor.PostVisit(plan *LogicalPlan) bool
			func PlanVisitor.PreVisit(plan *LogicalPlan) bool
			func github.com/polarsignals/frostdb/query/physicalplan.Build(ctx context.Context, pool memory.Allocator, tracer trace.Tracer, s *dynparquet.Schema, plan *LogicalPlan, options ...physicalplan.Option) (*physicalplan.OutputPlan, error)
			func github.com/polarsignals/frostdb/query/physicalplan.PostPlanVisitorFunc.PostVisit(plan *LogicalPlan) bool
			func github.com/polarsignals/frostdb/query/physicalplan.PostPlanVisitorFunc.PreVisit(_ *LogicalPlan) bool
			func github.com/polarsignals/frostdb/query/physicalplan.PrePlanVisitorFunc.PostVisit(_ *LogicalPlan) bool
			func github.com/polarsignals/frostdb/query/physicalplan.PrePlanVisitorFunc.PreVisit(plan *LogicalPlan) bool

	 type Named (interface)

		Methods (only one)
			( Named) Name() string
		Implemented By (at least 270)
			*AggregationFunction
			*AliasExpr
			*AllExpr
			*BinaryExpr
			*Column
			*ConvertExpr
			*DurationExpr
			*DynamicColumn
			 Expr (interface)
			*IfExpr
			*IsNullExpr
			*LiteralExpr
			*NotExpr
			 github.com/polarsignals/frostdb.DefaultObjstoreBucket
			*github.com/polarsignals/frostdb/dynparquet.Schema
			 github.com/polarsignals/frostdb/storage.Bucket (interface)
			 github.com/polarsignals/frostdb/storage.BucketReaderAt
			 github.com/polarsignals/frostdb/storage.FileReaderAt
			*github.com/polarsignals/wal/fs.File
			 github.com/apache/arrow-go/v18/arrow.BinaryDataType (interface)
			*github.com/apache/arrow-go/v18/arrow.BinaryType
			 github.com/apache/arrow-go/v18/arrow.BinaryViewDataType (interface)
			*github.com/apache/arrow-go/v18/arrow.BinaryViewType
			*github.com/apache/arrow-go/v18/arrow.BooleanType
			*github.com/apache/arrow-go/v18/arrow.Column
			 github.com/apache/arrow-go/v18/arrow.DataType (interface)
			*github.com/apache/arrow-go/v18/arrow.Date32Type
			*github.com/apache/arrow-go/v18/arrow.Date64Type
			*github.com/apache/arrow-go/v18/arrow.DayTimeIntervalType
			*github.com/apache/arrow-go/v18/arrow.Decimal128Type
			*github.com/apache/arrow-go/v18/arrow.Decimal256Type
			*github.com/apache/arrow-go/v18/arrow.Decimal32Type
			*github.com/apache/arrow-go/v18/arrow.Decimal64Type
			 github.com/apache/arrow-go/v18/arrow.DecimalType (interface)
			 github.com/apache/arrow-go/v18/arrow.DenseUnionType
			*github.com/apache/arrow-go/v18/arrow.DictionaryType
			*github.com/apache/arrow-go/v18/arrow.DurationType
			 github.com/apache/arrow-go/v18/arrow.EncodedType (interface)
			*github.com/apache/arrow-go/v18/arrow.ExtensionBase
			 github.com/apache/arrow-go/v18/arrow.ExtensionType (interface)
			*github.com/apache/arrow-go/v18/arrow.FixedSizeBinaryType
			*github.com/apache/arrow-go/v18/arrow.FixedSizeListType
			 github.com/apache/arrow-go/v18/arrow.FixedWidthDataType (interface)
			*github.com/apache/arrow-go/v18/arrow.Float16Type
			*github.com/apache/arrow-go/v18/arrow.Float32Type
			*github.com/apache/arrow-go/v18/arrow.Float64Type
			*github.com/apache/arrow-go/v18/arrow.Int16Type
			*github.com/apache/arrow-go/v18/arrow.Int32Type
			*github.com/apache/arrow-go/v18/arrow.Int64Type
			*github.com/apache/arrow-go/v18/arrow.Int8Type
			*github.com/apache/arrow-go/v18/arrow.LargeBinaryType
			 github.com/apache/arrow-go/v18/arrow.LargeListType
			*github.com/apache/arrow-go/v18/arrow.LargeListViewType
			*github.com/apache/arrow-go/v18/arrow.LargeStringType
			 github.com/apache/arrow-go/v18/arrow.ListLikeType (interface)
			*github.com/apache/arrow-go/v18/arrow.ListType
			*github.com/apache/arrow-go/v18/arrow.ListViewType
			*github.com/apache/arrow-go/v18/arrow.MapType
			*github.com/apache/arrow-go/v18/arrow.MonthDayNanoIntervalType
			*github.com/apache/arrow-go/v18/arrow.MonthIntervalType
			 github.com/apache/arrow-go/v18/arrow.NestedType (interface)
			*github.com/apache/arrow-go/v18/arrow.NullType
			 github.com/apache/arrow-go/v18/arrow.OffsetsDataType (interface)
			*github.com/apache/arrow-go/v18/arrow.RunEndEncodedType
			 github.com/apache/arrow-go/v18/arrow.SparseUnionType
			*github.com/apache/arrow-go/v18/arrow.StringType
			*github.com/apache/arrow-go/v18/arrow.StringViewType
			*github.com/apache/arrow-go/v18/arrow.StructType
			 github.com/apache/arrow-go/v18/arrow.TemporalWithUnit (interface)
			*github.com/apache/arrow-go/v18/arrow.Time32Type
			*github.com/apache/arrow-go/v18/arrow.Time64Type
			*github.com/apache/arrow-go/v18/arrow.TimestampType
			*github.com/apache/arrow-go/v18/arrow.Uint16Type
			*github.com/apache/arrow-go/v18/arrow.Uint32Type
			*github.com/apache/arrow-go/v18/arrow.Uint64Type
			*github.com/apache/arrow-go/v18/arrow.Uint8Type
			 github.com/apache/arrow-go/v18/arrow.UnionType (interface)
			 github.com/apache/arrow-go/v18/arrow.VarLenListLikeType (interface)
			*github.com/apache/arrow-go/v18/arrow/compute.FieldRef
			 github.com/apache/arrow-go/v18/arrow/compute.Function (interface)
			*github.com/apache/arrow-go/v18/arrow/compute.MetaFunction
			*github.com/apache/arrow-go/v18/arrow/compute.ScalarFunction
			*github.com/apache/arrow-go/v18/arrow/compute.VectorFunction
			*github.com/apache/arrow-go/v18/arrow/extensions.Bool8Type
			*github.com/apache/arrow-go/v18/arrow/extensions.JSONType
			*github.com/apache/arrow-go/v18/arrow/extensions.OpaqueType
			*github.com/apache/arrow-go/v18/arrow/extensions.UUIDType
			*github.com/apache/arrow-go/v18/arrow/extensions.VariantType
			*github.com/apache/arrow-go/v18/parquet/schema.Column
			*github.com/apache/arrow-go/v18/parquet/schema.GroupNode
			 github.com/apache/arrow-go/v18/parquet/schema.Node (interface)
			*github.com/apache/arrow-go/v18/parquet/schema.PrimitiveNode
			 github.com/coreos/etcd/pkg/fileutil.LockedFile
			*github.com/dop251/goja/file.File
			 github.com/efficientgo/core/testutil.TB (interface)
			*github.com/gdamore/tcell/v2.EventKey
			*github.com/go-viper/mapstructure/v2.DecodeError
			*github.com/goccy/go-json/internal/runtime.Type
			 github.com/google/flatbuffers/go.FlatbuffersCodec
			 github.com/google/go-cmp/cmp.StructField
			 github.com/google/go-cmp/cmp.Transform
			 github.com/hamba/avro/v2.EnumSchema
			*github.com/hamba/avro/v2.Field
			 github.com/hamba/avro/v2.FixedSchema
			 github.com/hamba/avro/v2.NamedSchema (interface)
			 github.com/hamba/avro/v2.Protocol
			 github.com/hamba/avro/v2.RecordSchema
			 github.com/K-Phoen/grabana/datasource.Datasource (interface)
			 github.com/libp2p/go-libp2p/core/connmgr.DecayingTag (interface)
			 github.com/libp2p/go-libp2p/core/event.Subscription (interface)
			*github.com/libp2p/go-libp2p/core/network.NullScope
			 github.com/libp2p/go-libp2p/core/network.ServiceScope (interface)
			 github.com/modern-go/reflect2.StructField (interface)
			 github.com/modern-go/reflect2.UnsafeArrayType
			 github.com/modern-go/reflect2.UnsafeEFaceType
			 github.com/modern-go/reflect2.UnsafeIFaceType
			 github.com/modern-go/reflect2.UnsafeMapType
			 github.com/modern-go/reflect2.UnsafePtrType
			 github.com/modern-go/reflect2.UnsafeSliceType
			*github.com/modern-go/reflect2.UnsafeStructField
			 github.com/modern-go/reflect2.UnsafeStructType
			*github.com/parquet-go/parquet-go.Column
			 github.com/parquet-go/parquet-go.Field (interface)
			*github.com/parquet-go/parquet-go.Schema
			*github.com/pion/sdp/v3.ExtMap
			*github.com/prometheus/common/model.Alert
			*github.com/redis/go-redis/v9.BoolCmd
			*github.com/redis/go-redis/v9.BoolSliceCmd
			*github.com/redis/go-redis/v9.ClusterLinksCmd
			*github.com/redis/go-redis/v9.ClusterShardsCmd
			*github.com/redis/go-redis/v9.ClusterSlotsCmd
			*github.com/redis/go-redis/v9.Cmd
			 github.com/redis/go-redis/v9.Cmder (interface)
			*github.com/redis/go-redis/v9.CommandsInfoCmd
			*github.com/redis/go-redis/v9.DurationCmd
			*github.com/redis/go-redis/v9.FloatCmd
			*github.com/redis/go-redis/v9.FloatSliceCmd
			*github.com/redis/go-redis/v9.FunctionListCmd
			*github.com/redis/go-redis/v9.FunctionStatsCmd
			*github.com/redis/go-redis/v9.GeoLocationCmd
			*github.com/redis/go-redis/v9.GeoPosCmd
			*github.com/redis/go-redis/v9.GeoSearchLocationCmd
			*github.com/redis/go-redis/v9.IntCmd
			*github.com/redis/go-redis/v9.IntSliceCmd
			*github.com/redis/go-redis/v9.KeyFlagsCmd
			*github.com/redis/go-redis/v9.KeyValueSliceCmd
			*github.com/redis/go-redis/v9.KeyValuesCmd
			*github.com/redis/go-redis/v9.LCSCmd
			*github.com/redis/go-redis/v9.MapStringIntCmd
			*github.com/redis/go-redis/v9.MapStringInterfaceCmd
			*github.com/redis/go-redis/v9.MapStringStringCmd
			*github.com/redis/go-redis/v9.MapStringStringSliceCmd
			*github.com/redis/go-redis/v9.ScanCmd
			*github.com/redis/go-redis/v9.SliceCmd
			*github.com/redis/go-redis/v9.SlowLogCmd
			*github.com/redis/go-redis/v9.StatusCmd
			*github.com/redis/go-redis/v9.StringCmd
			*github.com/redis/go-redis/v9.StringSliceCmd
			*github.com/redis/go-redis/v9.StringStructMapCmd
			*github.com/redis/go-redis/v9.TimeCmd
			*github.com/redis/go-redis/v9.XAutoClaimCmd
			*github.com/redis/go-redis/v9.XAutoClaimJustIDCmd
			*github.com/redis/go-redis/v9.XInfoConsumersCmd
			*github.com/redis/go-redis/v9.XInfoGroupsCmd
			*github.com/redis/go-redis/v9.XInfoStreamCmd
			*github.com/redis/go-redis/v9.XInfoStreamFullCmd
			*github.com/redis/go-redis/v9.XMessageSliceCmd
			*github.com/redis/go-redis/v9.XPendingCmd
			*github.com/redis/go-redis/v9.XPendingExtCmd
			*github.com/redis/go-redis/v9.XStreamSliceCmd
			*github.com/redis/go-redis/v9.ZSliceCmd
			*github.com/redis/go-redis/v9.ZSliceWithKeyCmd
			*github.com/redis/go-redis/v9.ZWithKeyCmd
			*github.com/reeflective/console.Menu
			*github.com/reeflective/readline/internal/history.Sources
			 github.com/rsteube/carapace/internal/pflagfork.FlagSet
			*github.com/spf13/cobra.Command
			*github.com/spf13/pflag.FlagSet
			 github.com/tetratelabs/wazero.CompiledModule (interface)
			 github.com/tetratelabs/wazero/api.CustomSection (interface)
			 github.com/tetratelabs/wazero/api.FunctionDefinition (interface)
			 github.com/tetratelabs/wazero/api.Module (interface)
			 github.com/tetratelabs/wazero/experimental.InternalModule (interface)
			 github.com/tetratelabs/wazero/internal/engine/wazevo/ssa.BasicBlock (interface)
			*github.com/tetratelabs/wazero/internal/wasm.FunctionDefinition
			*github.com/tetratelabs/wazero/internal/wasm.ModuleInstance
			 github.com/thanos-io/objstore.Bucket (interface)
			*github.com/thanos-io/objstore.InMemBucket
			 github.com/thanos-io/objstore.InstrumentedBucket (interface)
			*github.com/thanos-io/objstore.PrefixedBucket
			*database/sql.ColumnType
			*flag.FlagSet
			*go/token.File
			 go.opentelemetry.io/otel/sdk/trace.ReadOnlySpan (interface)
			 go.opentelemetry.io/otel/sdk/trace.ReadWriteSpan (interface)
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKExporterLogExported
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKExporterLogInflight
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKExporterMetricDataPointExported
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKExporterMetricDataPointInflight
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKExporterOperationDuration
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKExporterSpanExported
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKExporterSpanInflight
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKLogCreated
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKMetricReaderCollectionDuration
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorLogProcessed
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorLogQueueCapacity
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorLogQueueSize
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorSpanProcessed
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorSpanQueueCapacity
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorSpanQueueSize
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKSpanLive
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKSpanStarted
			*go.uber.org/zap.Logger
			*golang.org/x/sys/unix.Ifreq
			*gonum.org/v1/plot/font.Face
			*gonum.org/v1/plot/font.Font
			 google.golang.org/grpc/balancer.Builder (interface)
			 google.golang.org/grpc/encoding.Codec (interface)
			 google.golang.org/grpc/encoding.CodecV2 (interface)
			 google.golang.org/grpc/encoding.Compressor (interface)
			 google.golang.org/protobuf/internal/encoding/json.Token
			 gorm.io/driver/mysql.Dialector
			 gorm.io/driver/mysql.Migrator
			 gorm.io/gorm.ColumnType (interface)
			 gorm.io/gorm.Config
			 gorm.io/gorm.DB
			 gorm.io/gorm.Dialector (interface)
			 gorm.io/gorm.Index (interface)
			 gorm.io/gorm.Plugin (interface)
			 gorm.io/gorm.SoftDeleteDeleteClause
			 gorm.io/gorm.SoftDeleteQueryClause
			 gorm.io/gorm.SoftDeleteUpdateClause
			 gorm.io/gorm.Statement
			 gorm.io/gorm.TableType (interface)
			 gorm.io/gorm/clause.Delete
			 gorm.io/gorm/clause.From
			 gorm.io/gorm/clause.GroupBy
			 gorm.io/gorm/clause.Insert
			 gorm.io/gorm/clause.Interface (interface)
			 gorm.io/gorm/clause.Limit
			 gorm.io/gorm/clause.Locking
			 gorm.io/gorm/clause.OnConflict
			 gorm.io/gorm/clause.OrderBy
			 gorm.io/gorm/clause.Returning
			 gorm.io/gorm/clause.Select
			 gorm.io/gorm/clause.Set
			 gorm.io/gorm/clause.Update
			 gorm.io/gorm/clause.Values
			 gorm.io/gorm/clause.Where
			 gorm.io/gorm/migrator.ColumnType
			 gorm.io/gorm/migrator.Config
			 gorm.io/gorm/migrator.Index
			 gorm.io/gorm/migrator.Migrator
			 gorm.io/gorm/migrator.TableType
			*html/template.Template
			 internal/abi.Name
			*internal/godebug.Setting
			 internal/reflectlite.Type (interface)
			 io/fs.DirEntry (interface)
			 io/fs.FileInfo (interface)
			*os.File
			*os.Root
			 reflect.Type (interface)
			*runtime.Func
			*runtime/pprof.Profile
			*testing.B
			*testing.F
			*testing.T
			 testing.TB (interface)
			*text/template.Template

	 type NotExpr (struct)

		Fields (only one)
			Expr Expr
		Methods (total 10)
			(*NotExpr) Accept(visitor Visitor) bool
			(*NotExpr) Clone() Expr
			(*NotExpr) ColumnsUsedExprs() []Expr
			(*NotExpr) Computed() bool
			(*NotExpr) DataType(l ExprTypeFinder) (arrow.DataType, error)
			(*NotExpr) Equal(other Expr) bool
			(*NotExpr) MatchColumn(columnName string) bool
			(*NotExpr) MatchPath(path string) bool
			(*NotExpr) Name() string
			(*NotExpr) String() string
		Implements (at least 4)
			*NotExpr : Expr
			*NotExpr : Named
			*NotExpr : expvar.Var
			*NotExpr : fmt.Stringer
		As Outputs Of (at least one exported)
			func Not(expr Expr) *NotExpr

	 type Op uint32 (basic type)

		Methods (total 2)
			( Op) ArrowString() string
			( Op) String() string
		Implements (at least 2)
			 Op : expvar.Var
			 Op : fmt.Stringer
		As Inputs Of (at least 2)
			func github.com/polarsignals/frostdb/query/expr.BinaryScalarOperation(left parquet.ColumnChunk, right parquet.Value, operator Op) (bool, error)
			func github.com/polarsignals/frostdb/query/physicalplan.BinaryScalarOperation(left arrow.Array, right scalar.Scalar, operator Op) (*physicalplan.Bitmap, error)
		As Types Of (total 17)
			const OpAdd
			const OpAnd
			const OpContains
			const OpDiv
			const OpEq
			const OpGt
			const OpGtEq
			const OpLt
			const OpLtEq
			const OpMul
			const OpNotContains
			const OpNotEq
			const OpOr
			const OpRegexMatch
			const OpRegexNotMatch
			const OpSub
			const OpUnknown

	 type Optimizer (interface)

		Methods (only one)
			( Optimizer) Optimize(plan *LogicalPlan) *LogicalPlan
		Implemented By (at least 4)
			*AggFuncPushDown
			*DistinctPushDown
			*FilterPushDown
			*PhysicalProjectionPushDown
		As Outputs Of (at least one exported)
			func DefaultOptimizers() []Optimizer

	 type Option (func)

		As Outputs Of (at least 5)
			func WithDistinctColumns(e ...Expr) Option
			func WithFilter(e Expr) Option
			func WithPhysicalProjection(e ...Expr) Option
			func WithProjection(e ...Expr) Option
			func WithReadMode(m ReadMode) Option
		As Inputs Of (at least 4)
			func TableReader.Iterator(ctx context.Context, tx uint64, pool memory.Allocator, callbacks []Callback, options ...Option) error
			func TableReader.SchemaIterator(ctx context.Context, tx uint64, pool memory.Allocator, callbacks []Callback, options ...Option) error
			func github.com/polarsignals/frostdb.(*Table).Iterator(ctx context.Context, tx uint64, pool memory.Allocator, callbacks []Callback, options ...Option) error
			func github.com/polarsignals/frostdb.(*Table).SchemaIterator(ctx context.Context, tx uint64, pool memory.Allocator, callbacks []Callback, options ...Option) error

	 type PhysicalProjectionPushDown (struct)
		PhysicalProjectionPushDown finds the first projecting logical plan and
		collects all columns it needs, it is concatenated with all other columns
		used until it, for example a filter layer. Because the tree has the scan
		layer as the inner most layer, the logic actually works by resetting the
		list every time a projecting layer is found.

		Methods (only one)
			(*PhysicalProjectionPushDown) Optimize(plan *LogicalPlan) *LogicalPlan
		Implements (at least one exported)
			*PhysicalProjectionPushDown : Optimizer

	 type PlanValidationError (struct)
		PlanValidationError is the error representing a logical plan that is not valid.

		Methods (only one)
			(*PlanValidationError) Error() string
				PlanValidationError.Error prints the error message in a human-readable format.
				implements the error interface.

		Implements (at least one exported)
			*PlanValidationError : error
		As Outputs Of (at least 6)
			func ValidateAggregation(plan *LogicalPlan) *PlanValidationError
			func ValidateFilter(plan *LogicalPlan) *PlanValidationError
			func ValidateInput(plan *LogicalPlan) *PlanValidationError
			func ValidateSchemaScan(plan *LogicalPlan) *PlanValidationError
			func ValidateSingleFieldSet(plan *LogicalPlan) *PlanValidationError
			func ValidateTableScan(plan *LogicalPlan) *PlanValidationError

	 type PlanVisitor (interface)

		Methods (total 2)
			( PlanVisitor) PostVisit(plan *LogicalPlan) bool
			( PlanVisitor) PreVisit(plan *LogicalPlan) bool
		Implemented By (at least 2)
			 github.com/polarsignals/frostdb/query/physicalplan.PostPlanVisitorFunc
			 github.com/polarsignals/frostdb/query/physicalplan.PrePlanVisitorFunc
		As Inputs Of (at least one exported)
			func (*LogicalPlan).Accept(visitor PlanVisitor) bool

	 type Projection (struct)

		Fields (only one)
			Exprs []Expr
		Methods (only one)
			(*Projection) String() string
		Implements (at least 2)
			*Projection : expvar.Var
			*Projection : fmt.Stringer

	 type ReadMode int (basic type)

		As Inputs Of (at least 2)
			func WithReadMode(m ReadMode) Option
			func github.com/polarsignals/frostdb/query/physicalplan.WithReadMode(m ReadMode) physicalplan.Option
		As Types Of (total 3)
			const ReadModeDataSourcesOnly
			const ReadModeDefault
			const ReadModeInMemoryOnly

	 type Sample (struct)

		Fields (total 2)
			Expr Expr
			Limit Expr
		Methods (only one)
			(*Sample) String() string
		Implements (at least 2)
			*Sample : expvar.Var
			*Sample : fmt.Stringer

	 type SchemaScan (struct)

		Fields (total 7)
			Distinct []Expr
				Distinct describes the columns that are to be distinct.

			Filter Expr
				Filter is the predicate that is to be applied by the table scan to rule
				out any blocks of data to be scanned at all.

			PhysicalProjection []Expr
				PhysicalProjection describes the columns that are to be physically read
				by the table scan. This is an Expr so it can be either a column or
				dynamic column.

			Projection []Expr
				Projection is the list of columns that are to be projected.

			ReadMode ReadMode
				ReadMode indicates the mode to use when reading.

			TableName string
			TableProvider TableProvider
		Methods (total 2)
			(*SchemaScan) DataTypeForExpr(expr Expr) (arrow.DataType, error)
			(*SchemaScan) String() string
		Implements (at least 3)
			*SchemaScan : ExprTypeFinder
			*SchemaScan : expvar.Var
			*SchemaScan : fmt.Stringer

	 type TableProvider (interface)

		Methods (only one)
			( TableProvider) GetTable(name string) (TableReader, error)
		Implemented By (at least one exported)
			*github.com/polarsignals/frostdb.DBTableProvider
		As Inputs Of (at least 2)
			func Builder.Scan(provider TableProvider, tableName string) Builder
			func Builder.ScanSchema(provider TableProvider, tableName string) Builder

	 type TableReader (interface)

		Methods (total 4)
			( TableReader) Iterator(ctx context.Context, tx uint64, pool memory.Allocator, callbacks []Callback, options ...Option) error
			( TableReader) Schema() *dynparquet.Schema
			( TableReader) SchemaIterator(ctx context.Context, tx uint64, pool memory.Allocator, callbacks []Callback, options ...Option) error
			( TableReader) View(ctx context.Context, fn func(ctx context.Context, tx uint64) error) error
		Implemented By (at least 2)
			 github.com/polarsignals/frostdb.GenericTable[...]
			*github.com/polarsignals/frostdb.Table[*frostdb.Transition]
		As Outputs Of (at least 3)
			func (*LogicalPlan).TableReader() (TableReader, error)
			func TableProvider.GetTable(name string) (TableReader, error)
			func github.com/polarsignals/frostdb.(*DBTableProvider).GetTable(name string) (TableReader, error)

	 type TableScan (struct)

		Fields (total 7)
			Distinct []Expr
				Distinct describes the columns that are to be distinct.

			Filter Expr
				Filter is the predicate that is to be applied by the table scan to rule
				out any blocks of data to be scanned at all.

			PhysicalProjection []Expr
				PhysicalProjection describes the columns that are to be physically read
				by the table scan. This is an Expr so it can be either a column or
				dynamic column.

			Projection []Expr
				Projection is the list of columns that are to be projected.

			ReadMode ReadMode
				ReadMode indicates the mode to use when reading.

			TableName string
			TableProvider TableProvider
		Methods (total 2)
			(*TableScan) DataTypeForExpr(expr Expr) (arrow.DataType, error)
			(*TableScan) String() string
		Implements (at least 3)
			*TableScan : ExprTypeFinder
			*TableScan : expvar.Var
			*TableScan : fmt.Stringer

	 type Visitor (interface)

		Methods (total 3)
			( Visitor) PostVisit(expr Expr) bool
			( Visitor) PreVisit(expr Expr) bool
			( Visitor) Visit(expr Expr) bool
		Implemented By (at least 3)
			 github.com/polarsignals/frostdb/query/expr.PreExprVisitorFunc
			 github.com/polarsignals/frostdb/query/physicalplan.PreExprVisitorFunc
			 github.com/polarsignals/frostdb/pqarrow.PreExprVisitorFunc
		As Inputs Of (at least 13)
			func (*AggregationFunction).Accept(visitor Visitor) bool
			func (*AliasExpr).Accept(visitor Visitor) bool
			func (*AllExpr).Accept(visitor Visitor) bool
			func (*BinaryExpr).Accept(visitor Visitor) bool
			func (*Column).Accept(visitor Visitor) bool
			func (*ConvertExpr).Accept(visitor Visitor) bool
			func (*DurationExpr).Accept(visitor Visitor) bool
			func (*DynamicColumn).Accept(visitor Visitor) bool
			func Expr.Accept(Visitor) bool
			func (*IfExpr).Accept(visitor Visitor) bool
			func (*IsNullExpr).Accept(visitor Visitor) bool
			func (*LiteralExpr).Accept(visitor Visitor) bool
			func (*NotExpr).Accept(visitor Visitor) bool


Package-Level Functions (total 42)

	 func Add(left, right Expr) *BinaryExpr
	 func All() *AllExpr
	 func And(exprs ...Expr) Expr
	 func AndAgg(expr Expr) *AggregationFunction
	 func Avg(expr Expr) *AggregationFunction
	 func Col(name string) *Column
	 func Cols(names ...string) []Expr
	 func Convert(e Expr, t arrow.DataType) *ConvertExpr
	 func Count(expr Expr) *AggregationFunction
	 func DataTypeForExprWithSchema(expr Expr, s *dynparquet.Schema) (arrow.DataType, error)
	 func DefaultOptimizers() []Optimizer
	 func Div(left, right Expr) *BinaryExpr
	 func Duration(d time.Duration) *DurationExpr
	 func DynCol(name string) *DynamicColumn
	 func If(cond, then, els Expr) *IfExpr
	 func IsNull(expr Expr) *IsNullExpr
	 func Literal(v interface{}) *LiteralExpr
	 func Max(expr Expr) *AggregationFunction
	 func Min(expr Expr) *AggregationFunction
	 func Mul(left, right Expr) *BinaryExpr
	 func Not(expr Expr) *NotExpr
	 func Or(exprs ...Expr) Expr
	 func Sub(left, right Expr) *BinaryExpr
	 func Sum(expr Expr) *AggregationFunction
	 func Unique(expr Expr) *AggregationFunction
	 func Validate(plan *LogicalPlan) error
		Validate validates the logical plan.

	 func ValidateAggregation(plan *LogicalPlan) *PlanValidationError
		ValidateAggregation validates the logical plan's aggregation step.

	 func ValidateAggregationExpr(plan *LogicalPlan) *ExprValidationError
	 func ValidateComparingTypes(columnType *format.LogicalType, literal scalar.Scalar) *ExprValidationError
		ValidateComparingTypes validates if the types being compared by a binary expression are compatible.

	 func ValidateFilter(plan *LogicalPlan) *PlanValidationError
		ValidateFilter validates the logical plan's filter step.

	 func ValidateFilterAndBinaryExpr(plan *LogicalPlan, expr *BinaryExpr) *ExprValidationError
		ValidateFilterAndBinaryExpr validates the filter's binary expression where Op = AND.

	 func ValidateFilterBinaryExpr(plan *LogicalPlan, expr *BinaryExpr) *ExprValidationError
		ValidateFilterBinaryExpr validates the filter's binary expression.

	 func ValidateFilterExpr(plan *LogicalPlan, e Expr) *ExprValidationError
		ValidateFilterExpr validates filter's expression.

	 func ValidateInput(plan *LogicalPlan) *PlanValidationError
		ValidateInput validates that the current logical plans input is valid.
		It returns nil if the plan has no input.

	 func ValidateSchemaScan(plan *LogicalPlan) *PlanValidationError
	 func ValidateSingleFieldSet(plan *LogicalPlan) *PlanValidationError
		ValidateSingleFieldSet checks that only a single field is set on the plan.

	 func ValidateTableScan(plan *LogicalPlan) *PlanValidationError
	 func WithDistinctColumns(e ...Expr) Option
	 func WithFilter(e Expr) Option
	 func WithPhysicalProjection(e ...Expr) Option
	 func WithProjection(e ...Expr) Option
	 func WithReadMode(m ReadMode) Option
Package-Level Constants (total 28)

	const AggFuncAnd AggFunc = 7
	const AggFuncAvg AggFunc = 5
	const AggFuncCount AggFunc = 4
	const AggFuncMax AggFunc = 3
	const AggFuncMin AggFunc = 2
	const AggFuncSum AggFunc = 1
	const AggFuncUnique AggFunc = 6
	const AggFuncUnknown AggFunc = 0
	const OpAdd Op = 11
	const OpAnd Op = 9
	const OpContains Op = 15
	const OpDiv Op = 14
	const OpEq Op = 1
	const OpGt Op = 5
	const OpGtEq Op = 6
	const OpLt Op = 3
	const OpLtEq Op = 4
	const OpMul Op = 13
	const OpNotContains Op = 16
	const OpNotEq Op = 2
	const OpOr Op = 10
	const OpRegexMatch Op = 7
	const OpRegexNotMatch Op = 8
	const OpSub Op = 12
	const OpUnknown Op = 0
	const ReadModeDataSourcesOnly ReadMode = 2
		ReadModeDataSourcesOnly reads from data sources only.

	const ReadModeDefault ReadMode = 0
		ReadModeDefault is the default read mode. Reads from in-memory and object
		storage.

	const ReadModeInMemoryOnly ReadMode = 1
		ReadModeInMemoryOnly reads from in-memory storage only.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.