logical

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 TypeCast struct

+ func NewTypeCast(arg Expression, targetTypeID octosql.TypeID) *TypeCast

+ func (c *TypeCast) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) physical.Expression

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 LookupJoin struct

+ func NewLookupJoin(left, right Node) *LookupJoin

+ func (node *LookupJoin) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

+ type OrderSensitiveTransform struct

+ func NewOrderSensitiveTransform(keyExprs []Expression, directions []OrderDirection, limit *Expression, ...) *OrderSensitiveTransform

+ func (node *OrderSensitiveTransform) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

+ type OuterJoin struct

+ func NewOuterJoin(left, right Node, predicate Expression, isLeft, isRight bool) *OuterJoin

+ func (node *OuterJoin) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

+ type StreamJoin struct

+ func NewStreamJoin(left, right Node) *StreamJoin

+ func (node *StreamJoin) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

v0.7.4

Jun 21, 2022

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

type Limit

+ func (node *Limit) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

v0.5.0

Mar 27, 2022

Changes in this version

+ func TypecheckPossiblyNullableStruct(ctx context.Context, env physical.Environment, logicalEnv Environment, ...) physical.Expression

+ type ObjectFieldAccess struct

+ func NewObjectFieldAccess(object Expression, field string) *ObjectFieldAccess

+ func (c *ObjectFieldAccess) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) physical.Expression

v0.4.2

Jan 3, 2022

v0.4.1

Jan 3, 2022

v0.4.0

Dec 30, 2021

Changes in this version

+ func DirectionsToMultipliers(directions []OrderDirection) []int

+ func GetUniqueNameMatchingVariable(mapping map[string]string, name string) (string, bool)

+ func ReverseMapping(mapping map[string]string) map[string]string

+ func TypecheckExpression(ctx context.Context, env physical.Environment, logicalEnv Environment, ...) physical.Expression

+ type And struct

+ func NewAnd(left, right Expression) *And

+ func (and *And) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) physical.Expression

+ type Cast struct

+ func NewCast(arg Expression, targetType octosql.Type) *Cast

+ func (c *Cast) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) physical.Expression

+ type Coalesce struct

+ func NewCoalesce(args []Expression) *Coalesce

+ func (c *Coalesce) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) physical.Expression

+ type CommonTableExpression struct

+ Node physical.Node

+ UniqueVariableMapping map[string]string

type Constant

+ func (c *Constant) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) physical.Expression

type CountingTrigger

+ func (w *CountingTrigger) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment, ...) physical.Trigger

type DataSource

+ func (ds *DataSource) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

type DelayTrigger

+ func (w *DelayTrigger) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment, ...) physical.Trigger

type Distinct

+ func (node *Distinct) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

+ type EndOfStreamTrigger struct

+ func NewEndOfStreamTrigger() *EndOfStreamTrigger

+ func (w *EndOfStreamTrigger) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment, ...) physical.Trigger

+ type Environment struct

+ CommonTableExpressions map[string]CommonTableExpression

+ TableValuedFunctions map[string]TableValuedFunctionDescription

+ UniqueNameGenerator map[string]int

+ UniqueVariableNames *VariableMapping

+ func (env *Environment) GetUnique(name string) string

+ func (env *Environment) WithRecordUniqueVariableNames(record map[string]string) Environment

type Expression

+ Typecheck func(ctx context.Context, env physical.Environment, logicalEnv Environment) physical.Expression

+ type FieldNamer interface

+ FieldName func() string

type Filter

+ func (node *Filter) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

type FunctionExpression

+ Arguments []Expression

+ Name string

+ func (fe *FunctionExpression) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) physical.Expression

type GroupBy

+ func (node *GroupBy) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

type Join

+ func (node *Join) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

+ type JoinStrategy string

+ const JoinStrategyLookup

+ const JoinStrategyStream

+ const JoinStrategyUndefined

+ type JoinType string

+ const JoinTypeInner

+ const JoinTypeLeft

+ type LateralJoin struct

+ func NewLateralJoin(left, right Node) *LateralJoin

+ func (node *LateralJoin) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

type Map

+ func (node *Map) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

type Node

+ Typecheck func(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

+ type Or struct

+ func NewOr(left, right Expression) *Or

+ func (or *Or) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) physical.Expression

type OrderBy

+ func (node *OrderBy) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

+ type QueryExpression struct

+ func NewQueryExpression(node Node) *QueryExpression

+ func (ne *QueryExpression) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) physical.Expression

type Requalifier

+ func (node *Requalifier) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

type StarExpression

+ func (se *StarExpression) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) physical.Expression

type TableValuedFunction

+ func (node *TableValuedFunction) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

+ type TableValuedFunctionArgumentMatcher struct

+ Descriptor *TableValuedFunctionArgumentMatcherDescriptor

+ Expression *TableValuedFunctionArgumentMatcherExpression

+ Required bool

+ Table *TableValuedFunctionArgumentMatcherTable

+ TableValuedFunctionArgumentMatcherType physical.TableValuedFunctionArgumentType

+ type TableValuedFunctionArgumentMatcherDescriptor struct

+ type TableValuedFunctionArgumentMatcherExpression struct

+ Type octosql.Type

+ type TableValuedFunctionArgumentMatcherTable struct

type TableValuedFunctionArgumentValueDescriptor

+ func (arg *TableValuedFunctionArgumentValueDescriptor) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) physical.TableValuedFunctionArgument

type TableValuedFunctionArgumentValueExpression

+ func (arg *TableValuedFunctionArgumentValueExpression) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) physical.TableValuedFunctionArgument

type TableValuedFunctionArgumentValueTable

+ func (arg *TableValuedFunctionArgumentValueTable) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.TableValuedFunctionArgument, map[string]string)

+ type TableValuedFunctionDescription struct

+ Descriptors []TableValuedFunctionDescriptor

+ TypecheckArguments func(context.Context, physical.Environment, Environment, ...) map[string]TableValuedFunctionTypecheckedArgument

+ type TableValuedFunctionDescriptor struct

+ Arguments map[string]TableValuedFunctionArgumentMatcher

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

+ OutputSchema func(context.Context, physical.Environment, Environment, ...) (physical.Schema, map[string]string, error)

+ type TableValuedFunctionTypecheckedArgument struct

+ Argument physical.TableValuedFunctionArgument

+ Mapping map[string]string

type Trigger

+ Typecheck func(ctx context.Context, env physical.Environment, logicalEnv Environment, ...) physical.Trigger

type Tuple

+ func (t *Tuple) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) physical.Expression

type UnionAll

+ func (node *UnionAll) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

type UnionDistinct

+ func (node *UnionDistinct) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

type Variable

+ func (v *Variable) FieldName() string

+ func (v *Variable) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) physical.Expression

+ type VariableMapping struct

+ Mapping map[string]string

+ Parent *VariableMapping

+ func (mapping *VariableMapping) GetUniqueName(name string) (string, bool)

+ func (mapping *VariableMapping) WithRecordMapping(record map[string]string) *VariableMapping

type WatermarkTrigger

+ func (w *WatermarkTrigger) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment, ...) physical.Trigger

type With

+ func (node *With) Typecheck(ctx context.Context, env physical.Environment, logicalEnv Environment) (physical.Node, map[string]string)

v0.4.0-rc1

Dec 30, 2021

v0.3.0

Aug 5, 2020

Changes in this version

+ var ErrFallbackToLookupJoin = errors.New("fallback to lookup join")

type Aggregate

+ const Key

type AliasedExpression

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

type BooleanConstant

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

type Constant

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

+ type CountingTrigger struct

+ Count Expression

+ func NewCountingTrigger(count Expression) *CountingTrigger

+ func (w *CountingTrigger) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Trigger, octosql.Variables, error)

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

type DataSource

+ func (ds *DataSource) Visualize() *graph.Node

+ type DelayTrigger struct

+ Delay Expression

+ func NewDelayTrigger(delay Expression) *DelayTrigger

+ func (w *DelayTrigger) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Trigger, octosql.Variables, error)

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

type Distinct

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

type Filter

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

type FunctionExpression

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

type GroupBy

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

type InfixOperator

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

type Interval

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

+ type Join struct

+ func NewJoin(source, joined Node, joinType execution.JoinType) *Join

+ func (node *Join) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) ([]physical.Node, octosql.Variables, error)

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

+ func (node *Join) WithTriggers(triggers []Trigger) *Join

type LogicExpression

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

type Map

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

type NodeExpression

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

type OrderBy

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

+ type OutputOptions struct

+ Limit Expression

+ Offset Expression

+ OrderByDirections []OrderDirection

+ OrderByExpressions []Expression

+ func (opts *OutputOptions) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (*physical.OutputOptions, octosql.Variables, error)

type PhysicalPlanCreator

+ func (creator *PhysicalPlanCreator) WithCommonTableExpression(name string, nodes []physical.Node) *PhysicalPlanCreator

type Predicate

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

type PrefixOperator

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

type Relation

+ const Regexp

type Requalifier

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

+ type StarExpression struct

+ func NewStarExpression(qualifier string) *StarExpression

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

+ func (se *StarExpression) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Expression, octosql.Variables, error)

+ func (se *StarExpression) PhysicalNamed(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.NamedExpression, octosql.Variables, error)

+ func (se *StarExpression) 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 Trigger interface

+ Physical func(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Trigger, octosql.Variables, error)

+ Visualize func() *graph.Node

type Tuple

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

type UnionAll

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

type UnionDistinct

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

type Variable

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

+ type WatermarkTrigger struct

+ func NewWatermarkTrigger() *WatermarkTrigger

+ func (w *WatermarkTrigger) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Trigger, octosql.Variables, error)

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

+ type With struct

+ func NewWith(cteNames []string, cteNodes []Node, source Node) *With

+ func (node *With) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) ([]physical.Node, octosql.Variables, error)

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

v0.2.0

Sep 16, 2019

Changes in this version

+ func EqualTableValuedFunctionArgumentValue(value1 TableValuedFunctionArgumentValue, ...) error

+ type Interval struct

+ func NewInterval(count Expression, unit Expression) *Interval

+ func (v *Interval) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Expression, octosql.Variables, error)

+ type TableValuedFunction struct

+ func NewTableValuedFunction(name string, ...) *TableValuedFunction

+ func (node *TableValuedFunction) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Node, octosql.Variables, error)

+ type TableValuedFunctionArgumentValue interface

+ Physical func(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.TableValuedFunctionArgumentValue, octosql.Variables, error)

+ type TableValuedFunctionArgumentValueDescriptor struct

+ func NewTableValuedFunctionArgumentValueDescriptor(descriptor octosql.VariableName) *TableValuedFunctionArgumentValueDescriptor

+ func (arg *TableValuedFunctionArgumentValueDescriptor) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.TableValuedFunctionArgumentValue, octosql.Variables, error)

+ type TableValuedFunctionArgumentValueExpression struct

+ func NewTableValuedFunctionArgumentValueExpression(expression Expression) *TableValuedFunctionArgumentValueExpression

+ func (arg *TableValuedFunctionArgumentValueExpression) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.TableValuedFunctionArgumentValue, octosql.Variables, error)

+ type TableValuedFunctionArgumentValueTable struct

+ func NewTableValuedFunctionArgumentValueTable(source Node) *TableValuedFunctionArgumentValueTable

+ func (arg *TableValuedFunctionArgumentValueTable) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.TableValuedFunctionArgumentValue, octosql.Variables, error)

v0.1.1

Jul 21, 2019

v0.1.0

Jul 14, 2019

Changes in this version

+ var AggregateFunctions = map[Aggregate]struct

+ func EqualExpressions(expr1, expr2 Expression) error

+ func EqualFormula(expr1, expr2 Formula) error

+ func EqualNodes(node1, node2 Node) error

+ type Aggregate string

+ const Avg

+ const AvgDistinct

+ const Count

+ const CountDistinct

+ const First

+ const Last

+ const Max

+ const Min

+ const Sum

+ const SumDistinct

+ type AliasedExpression struct

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

+ func (alExpr *AliasedExpression) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Expression, octosql.Variables, error)

+ func (alExpr *AliasedExpression) PhysicalNamed(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.NamedExpression, octosql.Variables, error)

+ type BooleanConstant struct

+ Value bool

+ func NewBooleanConstant(value bool) *BooleanConstant

+ func (f *BooleanConstant) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Formula, octosql.Variables, error)

+ type Constant struct

+ func NewConstant(value interface{}) *Constant

+ func (v *Constant) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Expression, octosql.Variables, error)

+ type DataSource struct

+ func NewDataSource(name string, alias string) *DataSource

+ func (ds *DataSource) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Node, octosql.Variables, error)

+ type Distinct struct

+ func NewDistinct(child Node) *Distinct

+ func (node *Distinct) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Node, octosql.Variables, error)

+ type Expression interface

+ Physical func(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Expression, octosql.Variables, error)

+ type Filter struct

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

+ func (node *Filter) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Node, octosql.Variables, error)

+ type Formula interface

+ Physical func(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Formula, octosql.Variables, error)

+ type FunctionExpression struct

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

+ func (fe *FunctionExpression) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Expression, octosql.Variables, error)

+ type GroupBy struct

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

+ func (node *GroupBy) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Node, octosql.Variables, error)

+ type InfixOperator struct

+ Left Formula

+ Operator string

+ Right Formula

+ func NewInfixOperator(left Formula, right Formula, operator string) *InfixOperator

+ func (f *InfixOperator) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Formula, octosql.Variables, error)

+ type InnerJoin struct

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

+ func (node *InnerJoin) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Node, octosql.Variables, error)

+ type LeftJoin struct

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

+ func (node *LeftJoin) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Node, octosql.Variables, error)

+ type Limit struct

+ func (node *Limit) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Node, octosql.Variables, error)

+ type LogicExpression struct

+ func NewLogicExpression(formula Formula) *LogicExpression

+ func (le *LogicExpression) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Expression, octosql.Variables, error)

+ type Map struct

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

+ func (node *Map) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Node, octosql.Variables, error)

+ type NamedExpression interface

+ Name func() octosql.VariableName

+ PhysicalNamed func(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.NamedExpression, octosql.Variables, error)

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

+ type Node interface

+ Physical func(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Node, octosql.Variables, error)

+ func NewLimit(data Node, expr Expression) Node

+ func NewOffset(data Node, expr Expression) Node

+ type NodeExpression struct

+ func NewNodeExpression(node Node) *NodeExpression

+ func (ne *NodeExpression) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Expression, octosql.Variables, error)

+ type Offset struct

+ func (node *Offset) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Node, octosql.Variables, error)

+ type OrderBy struct

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

+ func (node *OrderBy) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Node, octosql.Variables, error)

+ type OrderDirection string

+ type PhysicalPlanCreator struct

+ func NewPhysicalPlanCreator(repo *physical.DataSourceRepository) *PhysicalPlanCreator

+ func (creator *PhysicalPlanCreator) GetVariableName() (out octosql.VariableName)

+ type Predicate struct

+ Left Expression

+ Relation Relation

+ Right Expression

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

+ func (f *Predicate) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Formula, octosql.Variables, error)

+ type PrefixOperator struct

+ Child Formula

+ Operator string

+ func NewPrefixOperator(child Formula, operator string) *PrefixOperator

+ func (f *PrefixOperator) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Formula, octosql.Variables, error)

+ 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) Physical(ctx context.Context) (physical.Relation, error)

+ type Requalifier struct

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

+ func (node *Requalifier) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Node, octosql.Variables, error)

+ type Tuple struct

+ func NewTuple(expressions []Expression) *Tuple

+ func (tup *Tuple) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Expression, octosql.Variables, error)

+ type UnionAll struct

+ func NewUnionAll(first, second Node) *UnionAll

+ func (node *UnionAll) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Node, octosql.Variables, error)

+ type UnionDistinct struct

+ func NewUnionDistinct(first, second Node) *UnionDistinct

+ func (node *UnionDistinct) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Node, octosql.Variables, error)

+ type Variable struct

+ func NewVariable(name octosql.VariableName) *Variable

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

+ func (v *Variable) Physical(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.Expression, octosql.Variables, error)

+ func (v *Variable) PhysicalNamed(ctx context.Context, physicalCreator *PhysicalPlanCreator) (physical.NamedExpression, octosql.Variables, error)

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