physical

package

Go to main page

Versions in this module

v0

v0.13.0

May 11, 2024

v0.12.2

May 30, 2023

v0.12.1

Feb 25, 2023

v0.12.0

Oct 19, 2022

v0.11.1

Oct 15, 2022

v0.11.0

Oct 2, 2022

v0.10.0

Sep 25, 2022

v0.9.4

Sep 4, 2022

v0.9.3

Aug 17, 2022

v0.9.2

Jul 24, 2022

Changes in this version

type Expression

+ TypeCast *TypeCast

type ExpressionType

+ const ExpressionTypeTypeCast

+ type TypeCast struct

+ Expression Expression

+ TargetTypeID octosql.TypeID

v0.9.1

Jul 17, 2022

v0.9.0

Jul 17, 2022

v0.8.1

Jul 17, 2022

v0.8.0

Jul 1, 2022

Changes in this version

type Node

+ OrderSensitiveTransform *OrderSensitiveTransform

+ OuterJoin *OuterJoin

type NodeType

+ const NodeTypeOrderSensitiveTransform

+ const NodeTypeOuterJoin

+ type OrderSensitiveTransform struct

+ Limit *Expression

+ OrderByDirectionMultipliers []int

+ OrderByKey []Expression

+ Source Node

+ type OuterJoin struct

+ IsLeft bool

+ IsRight bool

+ Left Node

+ LeftKey []Expression

+ Right Node

+ RightKey []Expression

v0.7.4

Jun 21, 2022

Changes in this version

+ type InMemoryRecords struct

+ Records []execution.Record

type Node

+ InMemoryRecords *InMemoryRecords

type NodeType

+ const NodeTypeInMemoryRecords

v0.7.3

Jun 1, 2022

v0.7.2

May 19, 2022

v0.7.1

May 14, 2022

v0.7.0

May 12, 2022

v0.6.2

Apr 18, 2022

v0.6.1

Apr 18, 2022

v0.6.0

Apr 15, 2022

Changes in this version

+ func WithNoRetractions(noRetractions bool) func(schema *Schema)

type Limit

+ Limit Expression

type Node

+ Limit *Limit

type NodeType

+ const NodeTypeLimit

type Schema

+ NoRetractions bool

+ type SchemaOption func(schema *Schema)

type Trigger

+ func (t *Trigger) NoRetractions() bool

v0.5.0

Mar 27, 2022

Changes in this version

type Cast

+ TargetTypeID octosql.TypeID

type Expression

+ ObjectFieldAccess *ObjectFieldAccess

type ExpressionType

+ const ExpressionTypeObjectFieldAccess

+ type ObjectFieldAccess struct

+ Field string

+ Object Expression

v0.4.2

Jan 3, 2022

v0.4.1

Jan 3, 2022

v0.4.0

Dec 30, 2021

Changes in this version

+ func ExplainExpr(expr Expression, withTypeInfo bool) *graph.Node

+ func ExplainNode(node Node, withTypeInfo bool) *graph.Node

+ func VariableNameMatchesField(varName, fieldName string) bool

type Aggregate

+ AggregateDescriptor AggregateDescriptor

+ Name string

+ OutputType octosql.Type

+ type AggregateDescriptor struct

+ ArgumentType octosql.Type

+ OutputType octosql.Type

+ Prototype func() nodes.Aggregate

+ TypeFn func(octosql.Type) (octosql.Type, bool)

+ type AggregateDetails struct

+ Description string

+ Descriptors []AggregateDescriptor

type And

+ Arguments []Expression

+ type Cast struct

+ Expression Expression

+ TargetType octosql.Type

+ type Coalesce struct

+ Arguments []Expression

type CountingTrigger

+ TriggerAfter uint

+ type Database interface

+ GetTable func(ctx context.Context, name string) (DatasourceImplementation, Schema, error)

+ ListTables func(ctx context.Context) ([]string, error)

+ type Datasource struct

+ Alias string

+ DatasourceImplementation DatasourceImplementation

+ Name string

+ Predicates []Expression

+ VariableMapping map[string]string

+ func (node *Datasource) PushDownPredicates(newPredicates, pushedDownPredicates []Expression) (rejected []Expression, pushedDown []Expression, changed bool)

+ type DatasourceImplementation interface

+ Materialize func(ctx context.Context, env Environment, schema Schema, ...) (execution.Node, error)

+ PushDownPredicates func(newPredicates, pushedDownPredicates []Expression) (rejected, pushedDown []Expression, changed bool)

+ type DatasourceRepository struct

+ Databases map[string]func() (Database, error)

+ DefaultDatabase string

+ FileHandlers map[string]func(name string) (DatasourceImplementation, Schema, error)

+ func (dr *DatasourceRepository) GetDatasource(ctx context.Context, name string) (DatasourceImplementation, Schema, error)

+ type EndOfStreamTrigger struct

+ type Environment struct

+ Aggregates map[string]AggregateDetails

+ Datasources *DatasourceRepository

+ Functions map[string]FunctionDetails

+ PhysicalConfig map[string]interface{}

+ VariableContext *VariableContext

+ func (env Environment) WithRecordSchema(schema Schema) Environment

type Expression

+ And *And

+ Cast *Cast

+ Coalesce *Coalesce

+ Constant *Constant

+ ExpressionType ExpressionType

+ FunctionCall *FunctionCall

+ Or *Or

+ QueryExpression *QueryExpression

+ Tuple *Tuple

+ Type octosql.Type

+ TypeAssertion *TypeAssertion

+ Variable *Variable

+ func RenameVariablesExpr(oldToNew map[string]string, expr Expression) Expression

+ func (expr Expression) SplitByAnd() []Expression

+ func (expr Expression) VariablesUsed() []string

+ type ExpressionType int

+ const ExpressionTypeAnd

+ const ExpressionTypeCast

+ const ExpressionTypeCoalesce

+ const ExpressionTypeConstant

+ const ExpressionTypeFunctionCall

+ const ExpressionTypeOr

+ const ExpressionTypeQueryExpression

+ const ExpressionTypeTuple

+ const ExpressionTypeTypeAssertion

+ const ExpressionTypeVariable

+ func (t ExpressionType) String() string

type Filter

+ Predicate Expression

+ type FunctionCall struct

+ Arguments []Expression

+ FunctionDescriptor FunctionDescriptor

+ Name string

+ type FunctionDescriptor struct

+ ArgumentTypes []octosql.Type

+ Function func([]octosql.Value) (octosql.Value, error)

+ OutputType octosql.Type

+ Strict bool

+ TypeFn func([]octosql.Type) (octosql.Type, bool)

+ type FunctionDetails struct

+ Description string

+ Descriptors []FunctionDescriptor

type GroupBy

+ AggregateExpressions []Expression

+ KeyEventTimeIndex int

+ Trigger Trigger

type LookupJoin

+ Joined Node

+ Source Node

+ type MultiTrigger struct

+ Triggers []Trigger

type Node

+ Datasource *Datasource

+ Distinct *Distinct

+ Filter *Filter

+ GroupBy *GroupBy

+ LookupJoin *LookupJoin

+ Map *Map

+ NodeType NodeType

+ OrderBy *OrderBy

+ Requalifier *Requalifier

+ Schema Schema

+ StreamJoin *StreamJoin

+ TableValuedFunction *TableValuedFunction

+ Unnest *Unnest

+ func RenameVariables(oldToNew map[string]string, node Node) Node

+ type NodeType int

+ const NodeTypeDatasource

+ const NodeTypeDistinct

+ const NodeTypeFilter

+ const NodeTypeGroupBy

+ const NodeTypeLookupJoin

+ const NodeTypeMap

+ const NodeTypeOrderBy

+ const NodeTypeRequalifier

+ const NodeTypeStreamJoin

+ const NodeTypeTableValuedFunction

+ const NodeTypeUnnest

+ func (t NodeType) String() string

type Or

+ Arguments []Expression

type OrderBy

+ DirectionMultipliers []int

+ Key []Expression

+ type QueryExpression struct

+ Source Node

+ type Schema struct

+ Fields []SchemaField

+ TimeField int

+ func NewSchema(fields []SchemaField, timeField int) Schema

+ type SchemaField struct

+ Name string

+ Type octosql.Type

type StreamJoin

+ Left Node

+ LeftKey []Expression

+ Right Node

+ RightKey []Expression

type TableValuedFunction

+ FunctionDescriptor TableValuedFunctionDescriptor

+ type TableValuedFunctionArgument struct

+ Descriptor *TableValuedFunctionArgumentDescriptor

+ Expression *TableValuedFunctionArgumentExpression

+ Table *TableValuedFunctionArgumentTable

+ TableValuedFunctionArgumentType TableValuedFunctionArgumentType

+ func (arg *TableValuedFunctionArgument) String() string

+ type TableValuedFunctionArgumentDescriptor struct

+ Descriptor string

+ type TableValuedFunctionArgumentExpression struct

+ Expression Expression

+ type TableValuedFunctionArgumentTable struct

+ Table Node

+ type TableValuedFunctionArgumentType int

+ const TableValuedFunctionArgumentTypeDescriptor

+ const TableValuedFunctionArgumentTypeExpression

+ const TableValuedFunctionArgumentTypeTable

+ type TableValuedFunctionDescriptor struct

+ Materialize func(context.Context, Environment, map[string]TableValuedFunctionArgument) (execution.Node, error)

type Transformers

+ ExpressionTransformer func(expr Expression) Expression

+ NodeTransformer func(node Node) Node

+ func (t *Transformers) TransformExpr(expr Expression) Expression

+ func (t *Transformers) TransformNode(node Node) Node

type Trigger

+ CountingTrigger *CountingTrigger

+ EndOfStreamTrigger *EndOfStreamTrigger

+ MultiTrigger *MultiTrigger

+ TriggerType TriggerType

+ WatermarkTrigger *WatermarkTrigger

+ type TriggerType int

+ const TriggerTypeCounting

+ const TriggerTypeEndOfStream

+ const TriggerTypeMulti

+ const TriggerTypeWatermark

+ func (t TriggerType) String() string

type Tuple

+ Arguments []Expression

+ type TypeAssertion struct

+ Expression Expression

+ TargetType octosql.Type

+ type Unnest struct

+ Field string

+ Source Node

type Variable

+ IsLevel0 bool

+ type VariableContext struct

+ Fields []SchemaField

+ Parent *VariableContext

+ func (varCtx *VariableContext) WithRecordSchema(schema Schema) *VariableContext

type WatermarkTrigger

+ TimeFieldIndex int

v0.4.0-rc1

Dec 30, 2021

v0.3.0

Aug 5, 2020

Changes in this version

type Aggregate

+ const Key

type AliasedExpression

+ ExpressionAlias octosql.VariableName

+ func (alExpr *AliasedExpression) DoesMatchNamespace(namespace *metadata.Namespace) bool

+ func (alExpr *AliasedExpression) ExpressionName() octosql.VariableName

+ func (alExpr *AliasedExpression) Visualize() *graph.Node

type And

+ func (f *And) DoesMatchNamespace(namespace *metadata.Namespace) bool

+ func (f *And) Visualize() *graph.Node

type Constant

+ func (f *Constant) DoesMatchNamespace(namespace *metadata.Namespace) bool

+ func (f *Constant) Visualize() *graph.Node

+ type ConstantStrategy struct

+ func (s *ConstantStrategy) Materialize(ctx context.Context, matCtx *MaterializationContext) (execution.ShuffleStrategyPrototype, error)

+ func (s *ConstantStrategy) Transform(ctx context.Context, transformers *Transformers) ShuffleStrategy

+ func (s *ConstantStrategy) Visualize() *graph.Node

+ type CountingTrigger struct

+ Count Expression

+ func NewCountingTrigger(count Expression) *CountingTrigger

+ func (c *CountingTrigger) Materialize(ctx context.Context, matCtx *MaterializationContext) (execution.TriggerPrototype, error)

+ func (c *CountingTrigger) Transform(ctx context.Context, transformers *Transformers) Trigger

+ func (c *CountingTrigger) Visualize() *graph.Node

type DataSourceBuilder

+ Partition int

+ func (dsb *DataSourceBuilder) Visualize() *graph.Node

+ type DataSourceMaterializerFunc func(ctx context.Context, matCtx *MaterializationContext, ...) (execution.Node, error)

type DataSourceRepository

+ func (repo *DataSourceRepository) WithFactory(dataSourceName string, factory DataSourceBuilderFactory) *DataSourceRepository

+ type DelayTrigger struct

+ Delay Expression

+ func NewDelayTrigger(delay Expression) *DelayTrigger

+ func (c *DelayTrigger) Materialize(ctx context.Context, matCtx *MaterializationContext) (execution.TriggerPrototype, error)

+ func (c *DelayTrigger) Transform(ctx context.Context, transformers *Transformers) Trigger

+ func (c *DelayTrigger) Visualize() *graph.Node

type Distinct

+ func (node *Distinct) Visualize() *graph.Node

type Expression

+ func NewRecordExpression() Expression

+ DoesMatchNamespace func(namespace *metadata.Namespace) bool

type Filter

+ func (node *Filter) Visualize() *graph.Node

type Formula

+ DoesMatchNamespace func(namespace *metadata.Namespace) bool

type FunctionExpression

+ Arguments []Expression

+ Name string

+ func (fe *FunctionExpression) DoesMatchNamespace(namespace *metadata.Namespace) bool

+ func (fe *FunctionExpression) Visualize() *graph.Node

type GroupBy

+ Triggers []Trigger

+ func (node *GroupBy) Visualize() *graph.Node

+ type KeyHashingStrategy struct

+ Key []Expression

+ func (s *KeyHashingStrategy) Materialize(ctx context.Context, matCtx *MaterializationContext) (execution.ShuffleStrategyPrototype, error)

+ func (s *KeyHashingStrategy) Transform(ctx context.Context, transformers *Transformers) ShuffleStrategy

+ func (s *KeyHashingStrategy) Visualize() *graph.Node

type LogicExpression

+ func (le *LogicExpression) DoesMatchNamespace(namespace *metadata.Namespace) bool

+ func (le *LogicExpression) Visualize() *graph.Node

+ type LookupJoin struct

+ func NewLookupJoin(source, joined Node, isLeftJoin bool) *LookupJoin

+ func (node *LookupJoin) Materialize(ctx context.Context, matCtx *MaterializationContext) (execution.Node, error)

+ func (node *LookupJoin) Metadata() *metadata.NodeMetadata

+ func (node *LookupJoin) Transform(ctx context.Context, transformers *Transformers) Node

+ func (node *LookupJoin) Visualize() *graph.Node

type Map

+ func (node *Map) Visualize() *graph.Node

type MaterializationContext

+ Storage storage.Storage

type NamedExpression

+ ExpressionName func() octosql.VariableName

+ type NextShuffleMetadataChange struct

+ Partition int

+ ShuffleIDAddSuffix string

+ Source Node

+ func NewNextShuffleMetadataChange(shuffleIDAddSuffix string, partition int, source Node) *NextShuffleMetadataChange

+ func (node *NextShuffleMetadataChange) Materialize(ctx context.Context, matCtx *MaterializationContext) (execution.Node, error)

+ func (node *NextShuffleMetadataChange) Metadata() *metadata.NodeMetadata

+ func (node *NextShuffleMetadataChange) Transform(ctx context.Context, transformers *Transformers) Node

+ func (node *NextShuffleMetadataChange) Visualize() *graph.Node

type Node

+ func NewShuffle(outputPartitionCount int, strategy ShuffleStrategy, sourceNodes []Node) []Node

type NodeExpression

+ func (ne *NodeExpression) DoesMatchNamespace(namespace *metadata.Namespace) bool

+ func (ne *NodeExpression) Visualize() *graph.Node

type Not

+ func (f *Not) DoesMatchNamespace(namespace *metadata.Namespace) bool

+ func (f *Not) Visualize() *graph.Node

type Or

+ func (f *Or) DoesMatchNamespace(namespace *metadata.Namespace) bool

+ func (f *Or) Visualize() *graph.Node

type OrderBy

+ func (node *OrderBy) Visualize() *graph.Node

+ type OutputOptions struct

+ Limit Expression

+ Offset Expression

+ OrderByDirections []OrderDirection

+ OrderByExpressions []Expression

+ func NewOutputOptions(orderByExpressions []Expression, orderByDirections []OrderDirection, ...) *OutputOptions

+ func (opts *OutputOptions) Materialize(ctx context.Context, matCtx *MaterializationContext) (*execution.OutputOptions, error)

type Predicate

+ func (f *Predicate) DoesMatchNamespace(namespace *metadata.Namespace) bool

+ func (f *Predicate) Visualize() *graph.Node

+ type RecordExpression struct

+ func (r *RecordExpression) DoesMatchNamespace(namespace *metadata.Namespace) bool

+ func (r *RecordExpression) Materialize(ctx context.Context, matCtx *MaterializationContext) (execution.Expression, error)

+ func (r *RecordExpression) Transform(ctx context.Context, transformers *Transformers) Expression

+ func (r *RecordExpression) Visualize() *graph.Node

type Relation

+ const Regexp

type Requalifier

+ func (node *Requalifier) Visualize() *graph.Node

+ type Shuffle struct

+ OutputPartitionCount int

+ Sources []Node

+ Strategy ShuffleStrategy

+ func (node *Shuffle) Materialize(ctx context.Context, matCtx *MaterializationContext) (execution.Node, error)

+ func (node *Shuffle) Metadata() *metadata.NodeMetadata

+ func (node *Shuffle) Transform(ctx context.Context, transformers *Transformers) Node

+ func (node *Shuffle) Visualize() *graph.Node

+ type ShuffleStrategy interface

+ Materialize func(ctx context.Context, matCtx *MaterializationContext) (execution.ShuffleStrategyPrototype, error)

+ Transform func(ctx context.Context, transformers *Transformers) ShuffleStrategy

+ Visualize func() *graph.Node

+ func NewConstantStrategy(partition int) ShuffleStrategy

+ func NewKeyHashingStrategy(key []Expression) ShuffleStrategy

+ type StarExpression struct

+ Qualifier string

+ func NewStarExpression(qualifier string) *StarExpression

+ func (se *StarExpression) DoesMatchNamespace(namespace *metadata.Namespace) bool

+ func (se *StarExpression) ExpressionName() octosql.VariableName

+ func (se *StarExpression) Materialize(ctx context.Context, matCtx *MaterializationContext) (execution.Expression, error)

+ func (se *StarExpression) MaterializeNamed(ctx context.Context, matCtx *MaterializationContext) (execution.NamedExpression, error)

+ func (se *StarExpression) Transform(ctx context.Context, transformers *Transformers) Expression

+ func (se *StarExpression) TransformNamed(ctx context.Context, transformers *Transformers) NamedExpression

+ func (se *StarExpression) Visualize() *graph.Node

+ type StreamJoin struct

+ EventTimeField octosql.VariableName

+ JoinType execution.JoinType

+ Joined Node

+ JoinedKey []Expression

+ Source Node

+ SourceKey []Expression

+ Triggers []Trigger

+ func NewStreamJoin(source, joined Node, sourceKey, joinedKey []Expression, ...) *StreamJoin

+ func (node *StreamJoin) Materialize(ctx context.Context, matCtx *MaterializationContext) (execution.Node, error)

+ func (node *StreamJoin) Metadata() *metadata.NodeMetadata

+ func (node *StreamJoin) Transform(ctx context.Context, transformers *Transformers) Node

+ func (node *StreamJoin) Visualize() *graph.Node

+ type StubNode struct

+ NodeMetadata *metadata.NodeMetadata

+ func NewStubNode(metadata *metadata.NodeMetadata) *StubNode

+ func (s *StubNode) Materialize(ctx context.Context, matCtx *MaterializationContext) (execution.Node, error)

+ func (s *StubNode) Metadata() *metadata.NodeMetadata

+ func (s *StubNode) Transform(ctx context.Context, transformers *Transformers) Node

+ func (s *StubNode) Visualize() *graph.Node

type TableValuedFunction

+ func (node *TableValuedFunction) Visualize() *graph.Node

type TableValuedFunctionArgumentValueDescriptor

+ func (arg *TableValuedFunctionArgumentValueDescriptor) Visualize() *graph.Node

type TableValuedFunctionArgumentValueExpression

+ func (arg *TableValuedFunctionArgumentValueExpression) Visualize() *graph.Node

type TableValuedFunctionArgumentValueTable

+ func (arg *TableValuedFunctionArgumentValueTable) Visualize() *graph.Node

type Transformers

+ ShuffleStrategyT func(ShuffleStrategy) ShuffleStrategy

+ TriggerT func(Trigger) Trigger

+ type Trigger interface

+ Materialize func(ctx context.Context, matCtx *MaterializationContext) (execution.TriggerPrototype, error)

+ Transform func(ctx context.Context, transformers *Transformers) Trigger

type Tuple

+ func (tup *Tuple) DoesMatchNamespace(namespace *metadata.Namespace) bool

+ func (tup *Tuple) Visualize() *graph.Node

type Variable

+ func (v *Variable) DoesMatchNamespace(namespace *metadata.Namespace) bool

+ func (v *Variable) ExpressionName() octosql.VariableName

+ func (v *Variable) Visualize() *graph.Node

+ type WatermarkTrigger struct

+ func NewWatermarkTrigger() *WatermarkTrigger

+ func (c *WatermarkTrigger) Materialize(ctx context.Context, matCtx *MaterializationContext) (execution.TriggerPrototype, error)

+ func (c *WatermarkTrigger) Transform(ctx context.Context, transformers *Transformers) Trigger

+ func (c *WatermarkTrigger) Visualize() *graph.Node

v0.2.0

Sep 16, 2019

Changes in this version

type DataSourceBuilder

+ Cardinality metadata.Cardinality

+ func (dsb *DataSourceBuilder) Metadata() *metadata.NodeMetadata

type Distinct

+ Source Node

+ func (node *Distinct) Metadata() *metadata.NodeMetadata

type Filter

+ func (node *Filter) Metadata() *metadata.NodeMetadata

type GroupBy

+ func (node *GroupBy) Metadata() *metadata.NodeMetadata

type InnerJoin

+ func (node *InnerJoin) Metadata() *metadata.NodeMetadata

type LeftJoin

+ func (node *LeftJoin) Metadata() *metadata.NodeMetadata

type Limit

+ LimitExpr Expression

+ Source Node

+ func (node *Limit) Metadata() *metadata.NodeMetadata

type Map

+ func (node *Map) Metadata() *metadata.NodeMetadata

type Node

+ Metadata func() *metadata.NodeMetadata

type Offset

+ OffsetExpr Expression

+ Source Node

+ func (node *Offset) Metadata() *metadata.NodeMetadata

type OrderBy

+ func (node *OrderBy) Metadata() *metadata.NodeMetadata

type Requalifier

+ func (node *Requalifier) Metadata() *metadata.NodeMetadata

+ type TableValuedFunction struct

+ Arguments map[octosql.VariableName]TableValuedFunctionArgumentValue

+ Name string

+ func NewTableValuedFunction(name string, args map[octosql.VariableName]TableValuedFunctionArgumentValue) *TableValuedFunction

+ func (node *TableValuedFunction) Materialize(ctx context.Context, matCtx *MaterializationContext) (execution.Node, error)

+ func (node *TableValuedFunction) Metadata() *metadata.NodeMetadata

+ func (node *TableValuedFunction) Transform(ctx context.Context, transformers *Transformers) Node

+ type TableValuedFunctionArgumentValue interface

+ Transform func(ctx context.Context, transformers *Transformers) TableValuedFunctionArgumentValue

+ type TableValuedFunctionArgumentValueDescriptor struct

+ Descriptor octosql.VariableName

+ func NewTableValuedFunctionArgumentValueDescriptor(descriptor octosql.VariableName) *TableValuedFunctionArgumentValueDescriptor

+ func (arg *TableValuedFunctionArgumentValueDescriptor) Transform(ctx context.Context, transformers *Transformers) TableValuedFunctionArgumentValue

+ type TableValuedFunctionArgumentValueExpression struct

+ Expression Expression

+ func NewTableValuedFunctionArgumentValueExpression(expression Expression) *TableValuedFunctionArgumentValueExpression

+ func (arg *TableValuedFunctionArgumentValueExpression) Transform(ctx context.Context, transformers *Transformers) TableValuedFunctionArgumentValue

+ type TableValuedFunctionArgumentValueTable struct

+ Source Node

+ func NewTableValuedFunctionArgumentValueTable(source Node) *TableValuedFunctionArgumentValueTable

+ func (arg *TableValuedFunctionArgumentValueTable) Transform(ctx context.Context, transformers *Transformers) TableValuedFunctionArgumentValue

type Transformers

+ TableValuedFunctionArgumentValueT func(TableValuedFunctionArgumentValue) TableValuedFunctionArgumentValue

type UnionAll

+ func (node *UnionAll) Metadata() *metadata.NodeMetadata

v0.1.1

Jul 21, 2019

Changes in this version

type DataSourceBuilder

+ Materializer func(ctx context.Context, matCtx *MaterializationContext, ...) (execution.Node, error)

+ Name string

type DataSourceRepository

+ func CreateDataSourceRepositoryFromConfig(factories map[string]Factory, config *config.Config) (*DataSourceRepository, error)

+ type Factory func(dbConfig map[string]interface{}) (DataSourceBuilderFactory, error)

+ type MaterializationContext struct

+ Config *config.Config

+ func NewMaterializationContext(config *config.Config) *MaterializationContext

v0.1.0

Jul 14, 2019

Changes in this version

+ type Aggregate string

+ const Avg

+ const AvgDistinct

+ const Count

+ const CountDistinct

+ const First

+ const Last

+ const Max

+ const Min

+ const Sum

+ const SumDistinct

+ func NewAggregate(aggregate string) Aggregate

+ type AliasedExpression struct

+ Expr Expression

+ Name octosql.VariableName

+ func NewAliasedExpression(name octosql.VariableName, expr Expression) *AliasedExpression

+ func (alExpr *AliasedExpression) Materialize(ctx context.Context) (execution.Expression, error)

+ func (alExpr *AliasedExpression) MaterializeNamed(ctx context.Context) (execution.NamedExpression, error)

+ func (alExpr *AliasedExpression) Transform(ctx context.Context, transformers *Transformers) Expression

+ func (alExpr *AliasedExpression) TransformNamed(ctx context.Context, transformers *Transformers) NamedExpression

+ type And struct

+ Left Formula

+ Right Formula

+ func NewAnd(left Formula, right Formula) *And

+ func (f *And) ExtractPredicates() []*Predicate

+ func (f *And) Materialize(ctx context.Context) (execution.Formula, error)

+ func (f *And) SplitByAnd() []Formula

+ func (f *And) Transform(ctx context.Context, transformers *Transformers) Formula

+ type Constant struct

+ Value bool

+ func NewConstant(value bool) *Constant

+ func (f *Constant) ExtractPredicates() []*Predicate

+ func (f *Constant) Materialize(ctx context.Context) (execution.Formula, error)

+ func (f *Constant) SplitByAnd() []Formula

+ func (f *Constant) Transform(ctx context.Context, transformers *Transformers) Formula

+ type DataSourceBuilder struct

+ Alias string

+ AvailableFilters map[FieldType]map[Relation]struct{}

+ Executor func(formula Formula, alias string) (execution.Node, error)

+ Filter Formula

+ PrimaryKeys []octosql.VariableName

+ func (dsb *DataSourceBuilder) Materialize(ctx context.Context) (execution.Node, error)

+ func (dsb *DataSourceBuilder) Transform(ctx context.Context, transformers *Transformers) Node

+ type DataSourceBuilderFactory func(alias string) *DataSourceBuilder

+ func NewDataSourceBuilderFactory(executor func(filter Formula, alias string) (execution.Node, error), ...) DataSourceBuilderFactory

+ type DataSourceRepository struct

+ func NewDataSourceRepository() *DataSourceRepository

+ func (repo *DataSourceRepository) Get(dataSourceName, alias string) (*DataSourceBuilder, error)

+ func (repo *DataSourceRepository) Register(dataSourceName string, factory DataSourceBuilderFactory) error

+ type Distinct struct

+ Child Node

+ func NewDistinct(child Node) *Distinct

+ func (node *Distinct) Materialize(ctx context.Context) (execution.Node, error)

+ func (node *Distinct) Transform(ctx context.Context, transformers *Transformers) Node

+ type Expression interface

+ Materialize func(ctx context.Context) (execution.Expression, error)

+ Transform func(ctx context.Context, transformers *Transformers) Expression

+ type FieldType string

+ const Primary

+ const Secondary

+ type Filter struct

+ Formula Formula

+ Source Node

+ func NewFilter(formula Formula, child Node) *Filter

+ func (node *Filter) Materialize(ctx context.Context) (execution.Node, error)

+ func (node *Filter) Transform(ctx context.Context, transformers *Transformers) Node

+ type Formula interface

+ ExtractPredicates func() []*Predicate

+ Materialize func(ctx context.Context) (execution.Formula, error)

+ SplitByAnd func() []Formula

+ Transform func(ctx context.Context, transformers *Transformers) Formula

+ type FunctionExpression struct

+ func NewFunctionExpression(name string, args []Expression) *FunctionExpression

+ func (fe *FunctionExpression) Materialize(ctx context.Context) (execution.Expression, error)

+ func (fe *FunctionExpression) Transform(ctx context.Context, transformers *Transformers) Expression

+ type GroupBy struct

+ Aggregates []Aggregate

+ As []octosql.VariableName

+ Fields []octosql.VariableName

+ Key []Expression

+ Source Node

+ func NewGroupBy(source Node, key []Expression, fields []octosql.VariableName, ...) *GroupBy

+ func (node *GroupBy) Materialize(ctx context.Context) (execution.Node, error)

+ func (node *GroupBy) Transform(ctx context.Context, transformers *Transformers) Node

+ type InnerJoin struct

+ Joined Node

+ Source Node

+ func NewInnerJoin(source Node, joined Node) *InnerJoin

+ func (node *InnerJoin) Materialize(ctx context.Context) (execution.Node, error)

+ func (node *InnerJoin) Transform(ctx context.Context, transformers *Transformers) Node

+ type LeftJoin struct

+ Joined Node

+ Source Node

+ func NewLeftJoin(source Node, joined Node) *LeftJoin

+ func (node *LeftJoin) Materialize(ctx context.Context) (execution.Node, error)

+ func (node *LeftJoin) Transform(ctx context.Context, transformers *Transformers) Node

+ type Limit struct

+ func NewLimit(data Node, expr Expression) *Limit

+ func (node *Limit) Materialize(ctx context.Context) (execution.Node, error)

+ func (node *Limit) Transform(ctx context.Context, transformers *Transformers) Node

+ type LogicExpression struct

+ Formula Formula

+ func NewLogicExpression(formula Formula) *LogicExpression

+ func (le *LogicExpression) Materialize(ctx context.Context) (execution.Expression, error)

+ func (le *LogicExpression) Transform(ctx context.Context, transformers *Transformers) Expression

+ type Map struct

+ Expressions []NamedExpression

+ Keep bool

+ Source Node

+ func NewMap(expressions []NamedExpression, child Node, keep bool) *Map

+ func (node *Map) Materialize(ctx context.Context) (execution.Node, error)

+ func (node *Map) Transform(ctx context.Context, transformers *Transformers) Node

+ type NamedExpression interface

+ MaterializeNamed func(ctx context.Context) (execution.NamedExpression, error)

+ TransformNamed func(ctx context.Context, transformers *Transformers) NamedExpression

+ type Node interface

+ Materialize func(ctx context.Context) (execution.Node, error)

+ Transform func(ctx context.Context, transformers *Transformers) Node

+ type NodeExpression struct

+ Node Node

+ func NewNodeExpression(node Node) *NodeExpression

+ func (ne *NodeExpression) Materialize(ctx context.Context) (execution.Expression, error)

+ func (ne *NodeExpression) Transform(ctx context.Context, transformers *Transformers) Expression

+ type Not struct

+ Child Formula

+ func NewNot(child Formula) *Not

+ func (f *Not) ExtractPredicates() []*Predicate

+ func (f *Not) Materialize(ctx context.Context) (execution.Formula, error)

+ func (f *Not) SplitByAnd() []Formula

+ func (f *Not) Transform(ctx context.Context, transformers *Transformers) Formula

+ type Offset struct

+ func NewOffset(data Node, expr Expression) *Offset

+ func (node *Offset) Materialize(ctx context.Context) (execution.Node, error)

+ func (node *Offset) Transform(ctx context.Context, transformers *Transformers) Node

+ type Or struct

+ Left Formula

+ Right Formula

+ func NewOr(left Formula, right Formula) *Or

+ func (f *Or) ExtractPredicates() []*Predicate

+ func (f *Or) Materialize(ctx context.Context) (execution.Formula, error)

+ func (f *Or) SplitByAnd() []Formula

+ func (f *Or) Transform(ctx context.Context, transformers *Transformers) Formula

+ type OrderBy struct

+ Directions []OrderDirection

+ Expressions []Expression

+ Source Node

+ func NewOrderBy(expressions []Expression, directions []OrderDirection, source Node) *OrderBy

+ func (node *OrderBy) Materialize(ctx context.Context) (execution.Node, error)

+ func (node *OrderBy) Transform(ctx context.Context, transformers *Transformers) Node

+ type OrderDirection string

+ const Ascending

+ const Descending

+ type Predicate struct

+ Left Expression

+ Relation Relation

+ Right Expression

+ func NewPredicate(left Expression, relation Relation, right Expression) *Predicate

+ func (f *Predicate) ExtractPredicates() []*Predicate

+ func (f *Predicate) Materialize(ctx context.Context) (execution.Formula, error)

+ func (f *Predicate) SplitByAnd() []Formula

+ func (f *Predicate) Transform(ctx context.Context, transformers *Transformers) Formula

+ type Relation string

+ const Equal

+ const GreaterEqual

+ const In

+ const LessEqual

+ const LessThan

+ const Like

+ const MoreThan

+ const NotEqual

+ const NotIn

+ func NewRelation(relation string) Relation

+ func (rel Relation) Materialize(ctx context.Context) execution.Relation

+ type Requalifier struct

+ Qualifier string

+ Source Node

+ func NewRequalifier(qualifier string, child Node) *Requalifier

+ func (node *Requalifier) Materialize(ctx context.Context) (execution.Node, error)

+ func (node *Requalifier) Transform(ctx context.Context, transformers *Transformers) Node

+ type Transformers struct

+ ExprT func(Expression) Expression

+ FormulaT func(Formula) Formula

+ NamedExprT func(NamedExpression) NamedExpression

+ NodeT func(Node) Node

+ type Tuple struct

+ Expressions []Expression

+ func NewTuple(expressions []Expression) *Tuple

+ func (tup *Tuple) Materialize(ctx context.Context) (execution.Expression, error)

+ func (tup *Tuple) Transform(ctx context.Context, transformers *Transformers) Expression

+ type UnionAll struct

+ First Node

+ Second Node

+ func NewUnionAll(first, second Node) *UnionAll

+ func (node *UnionAll) Materialize(ctx context.Context) (execution.Node, error)

+ func (node *UnionAll) Transform(ctx context.Context, transformers *Transformers) Node

+ type Variable struct

+ Name octosql.VariableName

+ func NewVariable(name octosql.VariableName) *Variable

+ func (v *Variable) Materialize(ctx context.Context) (execution.Expression, error)

+ func (v *Variable) MaterializeNamed(ctx context.Context) (execution.NamedExpression, error)

+ func (v *Variable) Transform(ctx context.Context, transformers *Transformers) Expression

+ func (v *Variable) TransformNamed(ctx context.Context, transformers *Transformers) NamedExpression

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