ast

package

Go to main page

Versions in this module

v0

v0.7.2

May 6, 2014

Changes in this version

type FunctionCallExpression

+ func NewFunctionCallSplit(operands FunctionArgExpressionList) FunctionCallExpression

+ type FunctionCallSplit struct

+ func (this *FunctionCallSplit) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallSplit) Copy() Expression

+ func (this *FunctionCallSplit) Evaluate(item *dparval.Value) (*dparval.Value, error)

v0.7.1

Mar 20, 2014

v0.7.0

Mar 18, 2014

Changes in this version

+ type BracketSliceMemberOperator struct

+ Left Expression

+ Middle Expression

+ Right Expression

+ Type string

+ func NewBracketSliceMemberOperator(left, middle, right Expression) *BracketSliceMemberOperator

+ func (this *BracketSliceMemberOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *BracketSliceMemberOperator) Copy() Expression

+ func (this *BracketSliceMemberOperator) Dependencies() ExpressionList

+ func (this *BracketSliceMemberOperator) EquivalentTo(t Expression) bool

+ func (this *BracketSliceMemberOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *BracketSliceMemberOperator) String() string

+ func (this *BracketSliceMemberOperator) UnmarshalJSON(data []byte) error

type CaseOperator

+ Switch Expression

type From

+ Keys *KeyExpression

+ Oper string

+ Type string

+ func (this *From) VerifyBucket(aliases []string) error

type FunctionCall

+ func (this *FunctionCall) EvaluateBoth(context *dparval.Value) (*dparval.Value, *dparval.Value, error)

+ func (this *FunctionCall) EvaluateBothRequireArray(context *dparval.Value) ([]interface{}, []interface{}, bool, error)

+ func (this *FunctionCall) EvaluateOperandsForArrayAppend(context *dparval.Value) ([]interface{}, error)

+ func (this *FunctionCall) EvaluateOperandsForArrayPrepend(context *dparval.Value) ([]interface{}, error)

+ func (this *FunctionCall) EvaluateOperandsForArrayRemove(context *dparval.Value) ([]interface{}, error)

+ type FunctionCallArrayAppend struct

+ func (this *FunctionCallArrayAppend) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallArrayAppend) Copy() Expression

+ func (this *FunctionCallArrayAppend) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type FunctionCallArrayConcat struct

+ func (this *FunctionCallArrayConcat) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallArrayConcat) Copy() Expression

+ func (this *FunctionCallArrayConcat) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type FunctionCallArrayLength struct

+ func (this *FunctionCallArrayLength) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallArrayLength) Copy() Expression

+ func (this *FunctionCallArrayLength) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallArrayPrepend struct

+ func (this *FunctionCallArrayPrepend) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallArrayPrepend) Copy() Expression

+ func (this *FunctionCallArrayPrepend) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type FunctionCallArrayRemove struct

+ func (this *FunctionCallArrayRemove) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallArrayRemove) Copy() Expression

+ func (this *FunctionCallArrayRemove) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type FunctionCallDatePartMillis struct

+ func (this *FunctionCallDatePartMillis) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallDatePartMillis) Copy() Expression

+ func (this *FunctionCallDatePartMillis) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallDatePartStr struct

+ func (this *FunctionCallDatePartStr) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallDatePartStr) Copy() Expression

+ func (this *FunctionCallDatePartStr) Evaluate(item *dparval.Value) (*dparval.Value, error)

type FunctionCallExpression

+ func NewFunctionCallArrayAppend(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallArrayConcat(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallArrayLength(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallArrayPrepend(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallArrayRemove(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallDatePartMillis(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallDatePartStr(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallIsArray(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallIsAtom(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallIsBool(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallIsNum(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallIsObj(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallIsStr(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallMillisToStr(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallNowMillis(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallObjectLength(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallPolyLength(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallStrToMillis(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallToArray(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallToAtom(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallToBool(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallToNum(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallToStr(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallTypeName(operands FunctionArgExpressionList) FunctionCallExpression

+ type FunctionCallIsArray struct

+ func (this *FunctionCallIsArray) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallIsArray) Copy() Expression

+ func (this *FunctionCallIsArray) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallIsAtom struct

+ func (this *FunctionCallIsAtom) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallIsAtom) Copy() Expression

+ func (this *FunctionCallIsAtom) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallIsBool struct

+ func (this *FunctionCallIsBool) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallIsBool) Copy() Expression

+ func (this *FunctionCallIsBool) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallIsNum struct

+ func (this *FunctionCallIsNum) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallIsNum) Copy() Expression

+ func (this *FunctionCallIsNum) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallIsObj struct

+ func (this *FunctionCallIsObj) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallIsObj) Copy() Expression

+ func (this *FunctionCallIsObj) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallIsStr struct

+ func (this *FunctionCallIsStr) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallIsStr) Copy() Expression

+ func (this *FunctionCallIsStr) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallMillisToStr struct

+ func (this *FunctionCallMillisToStr) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallMillisToStr) Copy() Expression

+ func (this *FunctionCallMillisToStr) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallNowMillis struct

+ func (this *FunctionCallNowMillis) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallNowMillis) Copy() Expression

+ func (this *FunctionCallNowMillis) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallObjectLength struct

+ func (this *FunctionCallObjectLength) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallObjectLength) Copy() Expression

+ func (this *FunctionCallObjectLength) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallPolyLength struct

+ func (this *FunctionCallPolyLength) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallPolyLength) Copy() Expression

+ func (this *FunctionCallPolyLength) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallStrToMillis struct

+ func (this *FunctionCallStrToMillis) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallStrToMillis) Copy() Expression

+ func (this *FunctionCallStrToMillis) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallToArray struct

+ func (this *FunctionCallToArray) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallToArray) Copy() Expression

+ func (this *FunctionCallToArray) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallToAtom struct

+ func (this *FunctionCallToAtom) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallToAtom) Copy() Expression

+ func (this *FunctionCallToAtom) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallToBool struct

+ func (this *FunctionCallToBool) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallToBool) Copy() Expression

+ func (this *FunctionCallToBool) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallToNum struct

+ func (this *FunctionCallToNum) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallToNum) Copy() Expression

+ func (this *FunctionCallToNum) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallToStr struct

+ func (this *FunctionCallToStr) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallToStr) Copy() Expression

+ func (this *FunctionCallToStr) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallTypeName struct

+ func (this *FunctionCallTypeName) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallTypeName) Copy() Expression

+ func (this *FunctionCallTypeName) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type InOperator struct

+ Type string

+ func NewInOperator(left, right Expression) *InOperator

+ func (this *InOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *InOperator) Copy() Expression

+ func (this *InOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type KeyExpression struct

+ Expr Expression

+ Keys []string

+ Type string

+ func NewKeyExpression(expr Expression, typeof string) *KeyExpression

+ func (this *KeyExpression) GetKeys() []string

+ func (this *KeyExpression) String() string

+ func (this *KeyExpression) Validate() error

+ type NotInOperator struct

+ Type string

+ func NewNotInOperator(left, right Expression) *NotInOperator

+ func (this *NotInOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *NotInOperator) Copy() Expression

+ func (this *NotInOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

type SelectStatement

+ Keys *KeyExpression

v0.6.1

Nov 6, 2013

v0.6.0

Nov 1, 2013

Changes in this version

type AndOperator

+ func (this *AndOperator) Copy() Expression

type BracketMemberOperator

+ func (this *BracketMemberOperator) Copy() Expression

type CaseOperator

+ func (this *CaseOperator) Copy() Expression

type ChangeSignOperator

+ func (this *ChangeSignOperator) Copy() Expression

type CollectionAllOperator

+ func (this *CollectionAllOperator) Copy() Expression

type CollectionAnyOperator

+ func (this *CollectionAnyOperator) Copy() Expression

type CollectionArrayOperator

+ func (this *CollectionArrayOperator) Copy() Expression

type CollectionFirstOperator

+ func (this *CollectionFirstOperator) Copy() Expression

type DivideOperator

+ func (this *DivideOperator) Copy() Expression

type DotMemberOperator

+ func (this *DotMemberOperator) Copy() Expression

type EqualToOperator

+ func (this *EqualToOperator) Copy() Expression

type Expression

+ Copy func() Expression

type FunctionArgExpression

+ func (this *FunctionArgExpression) Copy() *FunctionArgExpression

type FunctionArgExpressionList

+ func (this FunctionArgExpressionList) Copy() FunctionArgExpressionList

type FunctionCallArrayAgg

+ func (this *FunctionCallArrayAgg) Copy() Expression

type FunctionCallAvg

+ func (this *FunctionCallAvg) Copy() Expression

type FunctionCallBase64Value

+ func (this *FunctionCallBase64Value) Copy() Expression

type FunctionCallCeil

+ func (this *FunctionCallCeil) Copy() Expression

type FunctionCallCount

+ func (this *FunctionCallCount) Copy() Expression

+ type FunctionCallDatePart struct

+ func (this *FunctionCallDatePart) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallDatePart) Copy() Expression

+ func (this *FunctionCallDatePart) Evaluate(item *dparval.Value) (*dparval.Value, error)

type FunctionCallDisableLog

+ func (this *FunctionCallDisableLog) Copy() Expression

type FunctionCallEnableLog

+ func (this *FunctionCallEnableLog) Copy() Expression

type FunctionCallError

+ func (this *FunctionCallError) Copy() Expression

type FunctionCallExpression

+ func NewFunctionCallDatePart(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallNowStr(operands FunctionArgExpressionList) FunctionCallExpression

type FunctionCallFirstNum

+ func (this *FunctionCallFirstNum) Copy() Expression

type FunctionCallFloor

+ func (this *FunctionCallFloor) Copy() Expression

type FunctionCallGreatest

+ func (this *FunctionCallGreatest) Copy() Expression

type FunctionCallIfInf

+ func (this *FunctionCallIfInf) Copy() Expression

type FunctionCallIfMissing

+ func (this *FunctionCallIfMissing) Copy() Expression

type FunctionCallIfMissingOrNull

+ func (this *FunctionCallIfMissingOrNull) Copy() Expression

type FunctionCallIfNaN

+ func (this *FunctionCallIfNaN) Copy() Expression

type FunctionCallIfNaNOrInf

+ func (this *FunctionCallIfNaNOrInf) Copy() Expression

type FunctionCallIfNegInf

+ func (this *FunctionCallIfNegInf) Copy() Expression

type FunctionCallIfNull

+ func (this *FunctionCallIfNull) Copy() Expression

type FunctionCallIfPosInf

+ func (this *FunctionCallIfPosInf) Copy() Expression

type FunctionCallLTrim

+ func (this *FunctionCallLTrim) Copy() Expression

type FunctionCallLeast

+ func (this *FunctionCallLeast) Copy() Expression

type FunctionCallLength

+ func (this *FunctionCallLength) Copy() Expression

type FunctionCallLower

+ func (this *FunctionCallLower) Copy() Expression

type FunctionCallMax

+ func (this *FunctionCallMax) Copy() Expression

type FunctionCallMeta

+ func (this *FunctionCallMeta) Copy() Expression

type FunctionCallMin

+ func (this *FunctionCallMin) Copy() Expression

type FunctionCallMissingIf

+ func (this *FunctionCallMissingIf) Copy() Expression

type FunctionCallNaNIf

+ func (this *FunctionCallNaNIf) Copy() Expression

type FunctionCallNegInfIf

+ func (this *FunctionCallNegInfIf) Copy() Expression

+ type FunctionCallNowStr struct

+ func (this *FunctionCallNowStr) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallNowStr) Copy() Expression

+ func (this *FunctionCallNowStr) Evaluate(item *dparval.Value) (*dparval.Value, error)

type FunctionCallNullIf

+ func (this *FunctionCallNullIf) Copy() Expression

type FunctionCallPanic

+ func (this *FunctionCallPanic) Copy() Expression

type FunctionCallPosInfIf

+ func (this *FunctionCallPosInfIf) Copy() Expression

type FunctionCallRTrim

+ func (this *FunctionCallRTrim) Copy() Expression

type FunctionCallRound

+ func (this *FunctionCallRound) Copy() Expression

type FunctionCallSubStr

+ func (this *FunctionCallSubStr) Copy() Expression

type FunctionCallSum

+ func (this *FunctionCallSum) Copy() Expression

type FunctionCallTrim

+ func (this *FunctionCallTrim) Copy() Expression

type FunctionCallTrunc

+ func (this *FunctionCallTrunc) Copy() Expression

type FunctionCallUnknown

+ func (this *FunctionCallUnknown) Copy() Expression

type FunctionCallUpper

+ func (this *FunctionCallUpper) Copy() Expression

type FunctionCallValue

+ func (this *FunctionCallValue) Copy() Expression

type GreaterThanOperator

+ func (this *GreaterThanOperator) Copy() Expression

type GreaterThanOrEqualOperator

+ func (this *GreaterThanOrEqualOperator) Copy() Expression

type IsMissingOperator

+ func (this *IsMissingOperator) Copy() Expression

type IsNotMissingOperator

+ func (this *IsNotMissingOperator) Copy() Expression

type IsNotNullOperator

+ func (this *IsNotNullOperator) Copy() Expression

type IsNotValuedOperator

+ func (this *IsNotValuedOperator) Copy() Expression

type IsNullOperator

+ func (this *IsNullOperator) Copy() Expression

type IsValuedOperator

+ func (this *IsValuedOperator) Copy() Expression

type LessThanOperator

+ func (this *LessThanOperator) Copy() Expression

type LessThanOrEqualOperator

+ func (this *LessThanOrEqualOperator) Copy() Expression

type LikeOperator

+ func (this *LikeOperator) Copy() Expression

type LiteralArray

+ func (this *LiteralArray) Copy() Expression

type LiteralBool

+ func (this *LiteralBool) Copy() Expression

type LiteralNull

+ func (this *LiteralNull) Copy() Expression

type LiteralNumber

+ func (this *LiteralNumber) Copy() Expression

type LiteralObject

+ func (this *LiteralObject) Copy() Expression

type LiteralString

+ func (this *LiteralString) Copy() Expression

type ModuloOperator

+ func (this *ModuloOperator) Copy() Expression

type MultiplyOperator

+ func (this *MultiplyOperator) Copy() Expression

type NotEqualToOperator

+ func (this *NotEqualToOperator) Copy() Expression

type NotLikeOperator

+ func (this *NotLikeOperator) Copy() Expression

type NotOperator

+ func (this *NotOperator) Copy() Expression

type OrOperator

+ func (this *OrOperator) Copy() Expression

type PlusOperator

+ func (this *PlusOperator) Copy() Expression

type Property

+ func (this *Property) Copy() Expression

type StringConcatenateOperator

+ func (this *StringConcatenateOperator) Copy() Expression

type SubtractOperator

+ func (this *SubtractOperator) Copy() Expression

v0.5.1

Sep 12, 2013

v0.5.0

Sep 11, 2013

Changes in this version

+ var SystemFunctionRegistry map[string]FunctionCallConstructor = map[string]FunctionCallConstructor

+ func CollateJSON(key1, key2 interface{}) int

+ func DisableDeveloperFunctions()

+ func EnableDeveloperFunctions()

+ func RoundFloat(x float64, prec int) float64

+ func TruncateFloat(x float64, prec int) float64

+ func ValueInBooleanContext(val interface{}) interface

+ type AggregateFunctionCall struct

+ func (this AggregateFunctionCall) Key() string

+ type AggregateFunctionCallExpression interface

+ DefaultAggregate func(group *dparval.Value) error

+ Key func() string

+ UpdateAggregate func(group *dparval.Value, item *dparval.Value) error

+ type AndOperator struct

+ Type string

+ func NewAndOperator(operands ExpressionList) *AndOperator

+ func (this *AndOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *AndOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type BinaryOperator struct

+ Left Expression

+ Right Expression

+ func (this *BinaryOperator) Dependencies() ExpressionList

+ func (this *BinaryOperator) EquivalentTo(t Expression) bool

+ func (this *BinaryOperator) EvaluateBoth(context *dparval.Value) (*dparval.Value, *dparval.Value, error)

+ func (this *BinaryOperator) EvaluateBothRequireNumber(context *dparval.Value) (float64, float64, bool, error)

+ func (this *BinaryOperator) EvaluateBothRequireString(context *dparval.Value) (string, string, bool, error)

+ func (this *BinaryOperator) GetLeft() Expression

+ func (this *BinaryOperator) GetRight() Expression

+ func (this *BinaryOperator) Operator() string

+ func (this *BinaryOperator) SetLeft(left Expression)

+ func (this *BinaryOperator) SetRight(right Expression)

+ func (this *BinaryOperator) String() string

+ type BinaryOperatorExpression interface

+ GetLeft func() Expression

+ GetRight func() Expression

+ SetLeft func(Expression)

+ SetRight func(Expression)

+ type BracketMemberOperator struct

+ Left Expression

+ Right Expression

+ Type string

+ func NewBracketMemberOperator(left, right Expression) *BracketMemberOperator

+ func (this *BracketMemberOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *BracketMemberOperator) Dependencies() ExpressionList

+ func (this *BracketMemberOperator) EquivalentTo(t Expression) bool

+ func (this *BracketMemberOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *BracketMemberOperator) String() string

+ func (this *BracketMemberOperator) UnmarshalJSON(data []byte) error

+ type CaseOperator struct

+ Else Expression

+ Type string

+ WhenThens []*WhenThen

+ func NewCaseOperator() *CaseOperator

+ func (this *CaseOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *CaseOperator) Dependencies() ExpressionList

+ func (this *CaseOperator) EquivalentTo(t Expression) bool

+ func (this *CaseOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *CaseOperator) String() string

+ type ChangeSignOperator struct

+ Type string

+ func NewChangeSignOperator(operand Expression) *ChangeSignOperator

+ func (this *ChangeSignOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *ChangeSignOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type CollectionAllOperator struct

+ Type string

+ func NewCollectionAllOperator(condition Expression, over Expression, as string) *CollectionAllOperator

+ func (this *CollectionAllOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *CollectionAllOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type CollectionAnyOperator struct

+ Type string

+ func NewCollectionAnyOperator(condition Expression, over Expression, as string) *CollectionAnyOperator

+ func (this *CollectionAnyOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *CollectionAnyOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type CollectionArrayOperator struct

+ Type string

+ func NewCollectionArrayOperator(condition Expression, over Expression, as string, output Expression) *CollectionArrayOperator

+ func (this *CollectionArrayOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *CollectionArrayOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type CollectionFirstOperator struct

+ Type string

+ func NewCollectionFirstOperator(condition Expression, over Expression, as string, output Expression) *CollectionFirstOperator

+ func (this *CollectionFirstOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *CollectionFirstOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type CollectionOperator struct

+ As string

+ Condition Expression

+ Output Expression

+ Over Expression

+ func (this *CollectionOperator) Dependencies() ExpressionList

+ func (this *CollectionOperator) EquivalentTo(t Expression) bool

+ func (this *CollectionOperator) GetAs() string

+ func (this *CollectionOperator) GetCondition() Expression

+ func (this *CollectionOperator) GetOutput() Expression

+ func (this *CollectionOperator) GetOver() Expression

+ func (this *CollectionOperator) Operator() string

+ func (this *CollectionOperator) SetAs(as string)

+ func (this *CollectionOperator) SetCondition(condition Expression)

+ func (this *CollectionOperator) SetOutput(output Expression)

+ func (this *CollectionOperator) SetOver(over Expression)

+ func (this *CollectionOperator) String() string

+ type CollectionOperatorExpression interface

+ GetAs func() string

+ GetCondition func() Expression

+ GetOutput func() Expression

+ GetOver func() Expression

+ SetAs func(string)

+ SetCondition func(Expression)

+ SetOutput func(Expression)

+ SetOver func(Expression)

+ type CommutativeBinaryOperator struct

+ func (this *CommutativeBinaryOperator) EquivalentTo(t Expression) bool

+ type CreateIndexStatement struct

+ Bucket string

+ ExplainOnly bool

+ Method string

+ Name string

+ On ExpressionList

+ Pool string

+ Primary bool

+ func NewCreateIndexStatement() *CreateIndexStatement

+ func (this *CreateIndexStatement) IsExplainOnly() bool

+ func (this *CreateIndexStatement) SetExplainOnly(only bool)

+ func (this *CreateIndexStatement) Simplify() error

+ func (this *CreateIndexStatement) VerifySemantics() error

+ type DivideOperator struct

+ Type string

+ func NewDivideOperator(left, right Expression) *DivideOperator

+ func (this *DivideOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *DivideOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type DotMemberOperator struct

+ Left Expression

+ Right *Property

+ Type string

+ func NewDotMemberOperator(left Expression, right *Property) *DotMemberOperator

+ func (this *DotMemberOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *DotMemberOperator) Dependencies() ExpressionList

+ func (this *DotMemberOperator) EquivalentTo(t Expression) bool

+ func (this *DotMemberOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *DotMemberOperator) String() string

+ func (this *DotMemberOperator) UnmarshalJSON(data []byte) error

+ type DropIndexStatement struct

+ Bucket string

+ ExplainOnly bool

+ Name string

+ Pool string

+ func NewDropIndexStatement() *DropIndexStatement

+ func (this *DropIndexStatement) IsExplainOnly() bool

+ func (this *DropIndexStatement) SetExplainOnly(only bool)

+ func (this *DropIndexStatement) Simplify() error

+ func (this *DropIndexStatement) VerifySemantics() error

+ type DuplicateAlias struct

+ func (this *DuplicateAlias) Error() string

+ type EqualToOperator struct

+ Type string

+ func NewEqualToOperator(left, right Expression) *EqualToOperator

+ func (this *EqualToOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *EqualToOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type Expression interface

+ Accept func(ExpressionVisitor) (Expression, error)

+ Dependencies func() ExpressionList

+ EquivalentTo func(Expression) bool

+ Evaluate func(item *dparval.Value) (*dparval.Value, error)

+ func UnmarshalExpression(bytes []byte) (Expression, error)

+ func VisitChildren(v ExpressionVisitor, e Expression) (Expression, error)

+ type ExpressionAggregateFinder struct

+ func NewExpressionAggregateFinder() *ExpressionAggregateFinder

+ func (this *ExpressionAggregateFinder) GetAggregates() ExpressionList

+ func (this *ExpressionAggregateFinder) Visit(e Expression) (Expression, error)

+ type ExpressionCNF struct

+ func NewExpressionCNF() *ExpressionCNF

+ func (this *ExpressionCNF) Visit(e Expression) (Expression, error)

+ type ExpressionEquivalenceChecker struct

+ Expressions ExpressionList

+ func NewExpressionEquivalenceChecker(exprs ExpressionList) *ExpressionEquivalenceChecker

+ func (this *ExpressionEquivalenceChecker) Visit(expr Expression) (Expression, error)

+ type ExpressionFormalNotationConverter struct

+ func NewExpressionFormalNotationConverter(forbiddenAliases []string, aliases []string, defaultAlias string) *ExpressionFormalNotationConverter

+ func (this *ExpressionFormalNotationConverter) Visit(e Expression) (Expression, error)

+ func (this *ExpressionFormalNotationConverter) VisitCollectionChild(expr CollectionOperatorExpression) error

+ func (this *ExpressionFormalNotationConverter) VisitDotMemberChild(expr *DotMemberOperator) (Expression, error)

+ func (this *ExpressionFormalNotationConverter) VisitFunctionCall(expr FunctionCallExpression) error

+ func (this *ExpressionFormalNotationConverter) VisitProperty(expr *Property) (Expression, error)

+ type ExpressionFunctionalDependencyChecker struct

+ AggregatesSatisfied bool

+ Dependencies ExpressionList

+ func NewExpressionFunctionalDependencyChecker(deps ExpressionList) *ExpressionFunctionalDependencyChecker

+ func NewExpressionFunctionalDependencyCheckerFull(deps ExpressionList) *ExpressionFunctionalDependencyChecker

+ func (this *ExpressionFunctionalDependencyChecker) Visit(expr Expression) (Expression, error)

+ type ExpressionList []Expression

+ func (this ExpressionList) EquivalentTo(e Expression) Expression

+ func (this ExpressionList) Simplify() error

+ func (this ExpressionList) Validate() error

+ func (this ExpressionList) VerifyFormalNotation(forbiddenAliases []string, aliases []string, defaultAlias string) error

+ type ExpressionNNF struct

+ func NewExpressionNNF() *ExpressionNNF

+ func (this *ExpressionNNF) Visit(e Expression) (Expression, error)

+ type ExpressionSimplifier struct

+ func NewExpressionSimplifier() *ExpressionSimplifier

+ func (this *ExpressionSimplifier) Visit(e Expression) (Expression, error)

+ type ExpressionValidator struct

+ func NewExpressionValidator() *ExpressionValidator

+ func NewExpressionValidatorNoAggregates() *ExpressionValidator

+ func (this *ExpressionValidator) ValidateFunctionCall(expr FunctionCallExpression) error

+ func (this *ExpressionValidator) Visit(e Expression) (Expression, error)

+ type ExpressionVisitor interface

+ Visit func(Expression) (Expression, error)

+ type From struct

+ As string

+ Bucket string

+ Over *From

+ Pool string

+ Projection Expression

+ func (this *From) ConvertToBucketFrom()

+ func (this *From) GenerateAlias()

+ func (this *From) GetAliases() []string

+ type FunctionArgExpression struct

+ Expr Expression

+ Star bool

+ func NewDotStarFunctionArgExpression(expr Expression) *FunctionArgExpression

+ func NewFunctionArgExpression(expr Expression) *FunctionArgExpression

+ func NewStarFunctionArgExpression() *FunctionArgExpression

+ func (this *FunctionArgExpression) EquivalentTo(that *FunctionArgExpression) bool

+ func (this *FunctionArgExpression) String() string

+ type FunctionArgExpressionList []*FunctionArgExpression

+ func (this FunctionArgExpressionList) String() string

+ type FunctionCall struct

+ Distinct bool

+ Name string

+ Operands FunctionArgExpressionList

+ Type string

+ func (this *FunctionCall) Dependencies() ExpressionList

+ func (this *FunctionCall) EquivalentTo(t Expression) bool

+ func (this *FunctionCall) GetName() string

+ func (this *FunctionCall) GetOperands() FunctionArgExpressionList

+ func (this *FunctionCall) IsDistinct() bool

+ func (this *FunctionCall) SetDistinct(distinct bool)

+ func (this *FunctionCall) SetOperands(operands FunctionArgExpressionList)

+ func (this *FunctionCall) String() string

+ func (this *FunctionCall) ValidateArity() error

+ func (this *FunctionCall) ValidateDistinct() error

+ func (this *FunctionCall) ValidateStars() error

+ type FunctionCallArrayAgg struct

+ func (this *FunctionCallArrayAgg) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallArrayAgg) DefaultAggregate(group *dparval.Value) error

+ func (this *FunctionCallArrayAgg) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *FunctionCallArrayAgg) UpdateAggregate(group *dparval.Value, item *dparval.Value) error

+ type FunctionCallAvg struct

+ func (this *FunctionCallAvg) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallAvg) DefaultAggregate(group *dparval.Value) error

+ func (this *FunctionCallAvg) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *FunctionCallAvg) UpdateAggregate(group *dparval.Value, item *dparval.Value) error

+ type FunctionCallBase64Value struct

+ func (this *FunctionCallBase64Value) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallBase64Value) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallCeil struct

+ func (this *FunctionCallCeil) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallCeil) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallConstructor func(operands FunctionArgExpressionList) FunctionCallExpression

+ type FunctionCallCount struct

+ func (this *FunctionCallCount) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallCount) DefaultAggregate(group *dparval.Value) error

+ func (this *FunctionCallCount) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *FunctionCallCount) UpdateAggregate(group *dparval.Value, item *dparval.Value) error

+ type FunctionCallDisableLog struct

+ func (this *FunctionCallDisableLog) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallDisableLog) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallEnableLog struct

+ func (this *FunctionCallEnableLog) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallEnableLog) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallError struct

+ func (this *FunctionCallError) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallError) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallExpression interface

+ GetName func() string

+ GetOperands func() FunctionArgExpressionList

+ IsDistinct func() bool

+ SetDistinct func(bool)

+ SetOperands func(FunctionArgExpressionList)

+ ValidateArity func() error

+ ValidateDistinct func() error

+ ValidateStars func() error

+ func NewFunctionCall(name string, operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallArrayAgg(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallAvg(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallBase64Value(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallCeil(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallCount(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallDisableLog(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallEnableLog(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallError(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallFirstNum(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallFloor(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallGreatest(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallIfInf(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallIfMissing(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallIfMissingOrNull(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallIfNaN(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallIfNaNOrInf(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallIfNegInf(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallIfNull(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallIfPosInf(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallLTrim(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallLeast(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallLength(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallLower(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallMax(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallMeta(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallMin(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallMissingIf(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallNaNIf(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallNegInfIf(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallNullIf(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallPanic(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallPosInfIf(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallRTrim(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallRound(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallSubStr(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallSum(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallTrim(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallTrunc(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallUnknown(operands FunctionArgExpressionList, name string) FunctionCallExpression

+ func NewFunctionCallUpper(operands FunctionArgExpressionList) FunctionCallExpression

+ func NewFunctionCallValue(operands FunctionArgExpressionList) FunctionCallExpression

+ type FunctionCallFirstNum struct

+ func (this *FunctionCallFirstNum) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallFirstNum) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallFloor struct

+ func (this *FunctionCallFloor) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallFloor) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallGreatest struct

+ func (this *FunctionCallGreatest) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallGreatest) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallIfInf struct

+ func (this *FunctionCallIfInf) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallIfInf) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallIfMissing struct

+ func (this *FunctionCallIfMissing) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallIfMissing) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallIfMissingOrNull struct

+ func (this *FunctionCallIfMissingOrNull) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallIfMissingOrNull) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallIfNaN struct

+ func (this *FunctionCallIfNaN) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallIfNaN) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallIfNaNOrInf struct

+ func (this *FunctionCallIfNaNOrInf) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallIfNaNOrInf) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallIfNegInf struct

+ func (this *FunctionCallIfNegInf) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallIfNegInf) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallIfNull struct

+ func (this *FunctionCallIfNull) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallIfNull) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallIfPosInf struct

+ func (this *FunctionCallIfPosInf) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallIfPosInf) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallLTrim struct

+ func (this *FunctionCallLTrim) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallLTrim) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallLeast struct

+ func (this *FunctionCallLeast) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallLeast) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallLength struct

+ func (this *FunctionCallLength) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallLength) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallLower struct

+ func (this *FunctionCallLower) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallLower) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallMax struct

+ func (this *FunctionCallMax) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallMax) DefaultAggregate(group *dparval.Value) error

+ func (this *FunctionCallMax) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *FunctionCallMax) UpdateAggregate(group *dparval.Value, item *dparval.Value) error

+ type FunctionCallMeta struct

+ func (this *FunctionCallMeta) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallMeta) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallMin struct

+ func (this *FunctionCallMin) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallMin) DefaultAggregate(group *dparval.Value) error

+ func (this *FunctionCallMin) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *FunctionCallMin) UpdateAggregate(group *dparval.Value, item *dparval.Value) error

+ type FunctionCallMissingIf struct

+ func (this *FunctionCallMissingIf) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallMissingIf) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallNaNIf struct

+ func (this *FunctionCallNaNIf) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallNaNIf) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallNegInfIf struct

+ func (this *FunctionCallNegInfIf) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallNegInfIf) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallNullIf struct

+ func (this *FunctionCallNullIf) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallNullIf) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallPanic struct

+ func (this *FunctionCallPanic) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallPanic) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallPosInfIf struct

+ func (this *FunctionCallPosInfIf) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallPosInfIf) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallRTrim struct

+ func (this *FunctionCallRTrim) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallRTrim) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallRound struct

+ func (this *FunctionCallRound) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallRound) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallSubStr struct

+ func (this *FunctionCallSubStr) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallSubStr) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallSum struct

+ func (this *FunctionCallSum) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallSum) DefaultAggregate(group *dparval.Value) error

+ func (this *FunctionCallSum) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *FunctionCallSum) UpdateAggregate(group *dparval.Value, item *dparval.Value) error

+ type FunctionCallTrim struct

+ func (this *FunctionCallTrim) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallTrim) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallTrunc struct

+ func (this *FunctionCallTrunc) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallTrunc) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallUnknown struct

+ func (this *FunctionCallUnknown) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallUnknown) Arity() (int, int)

+ func (this *FunctionCallUnknown) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallUpper struct

+ func (this *FunctionCallUpper) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallUpper) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type FunctionCallValue struct

+ func (this *FunctionCallValue) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *FunctionCallValue) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type GreaterThanOperator struct

+ Type string

+ func NewGreaterThanOperator(left, right Expression) *GreaterThanOperator

+ func (this *GreaterThanOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *GreaterThanOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type GreaterThanOrEqualOperator struct

+ Type string

+ func NewGreaterThanOrEqualOperator(left, right Expression) *GreaterThanOrEqualOperator

+ func (this *GreaterThanOrEqualOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *GreaterThanOrEqualOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type IsMissingOperator struct

+ Type string

+ func NewIsMissingOperator(operand Expression) *IsMissingOperator

+ func (this *IsMissingOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *IsMissingOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type IsNotMissingOperator struct

+ Type string

+ func NewIsNotMissingOperator(operand Expression) *IsNotMissingOperator

+ func (this *IsNotMissingOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *IsNotMissingOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type IsNotNullOperator struct

+ Type string

+ func NewIsNotNullOperator(operand Expression) *IsNotNullOperator

+ func (this *IsNotNullOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *IsNotNullOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type IsNotValuedOperator struct

+ Type string

+ func NewIsNotValuedOperator(operand Expression) *IsNotValuedOperator

+ func (this *IsNotValuedOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *IsNotValuedOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type IsNullOperator struct

+ Type string

+ func NewIsNullOperator(operand Expression) *IsNullOperator

+ func (this *IsNullOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *IsNullOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type IsValuedOperator struct

+ Type string

+ func NewIsValuedOperator(operand Expression) *IsValuedOperator

+ func (this *IsValuedOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *IsValuedOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type LessThanOperator struct

+ Type string

+ func NewLessThanOperator(left, right Expression) *LessThanOperator

+ func (this *LessThanOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *LessThanOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type LessThanOrEqualOperator struct

+ Type string

+ func NewLessThanOrEqualOperator(left, right Expression) *LessThanOrEqualOperator

+ func (this *LessThanOrEqualOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *LessThanOrEqualOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type LikeOperator struct

+ Type string

+ func NewLikeOperator(left, right Expression) *LikeOperator

+ func (this *LikeOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *LikeOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type LiteralArray struct

+ Type string

+ Val ExpressionList

+ func NewLiteralArray(val ExpressionList) *LiteralArray

+ func (this *LiteralArray) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *LiteralArray) Dependencies() ExpressionList

+ func (this *LiteralArray) EquivalentTo(t Expression) bool

+ func (this *LiteralArray) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *LiteralArray) String() string

+ type LiteralBool struct

+ Type string

+ Val bool

+ func NewLiteralBool(val bool) *LiteralBool

+ func (this *LiteralBool) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *LiteralBool) Dependencies() ExpressionList

+ func (this *LiteralBool) EquivalentTo(t Expression) bool

+ func (this *LiteralBool) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *LiteralBool) String() string

+ type LiteralNull struct

+ Type string

+ func NewLiteralNull() *LiteralNull

+ func (this *LiteralNull) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *LiteralNull) Dependencies() ExpressionList

+ func (this *LiteralNull) EquivalentTo(t Expression) bool

+ func (this *LiteralNull) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *LiteralNull) String() string

+ type LiteralNumber struct

+ Type string

+ Val float64

+ func NewLiteralNumber(val float64) *LiteralNumber

+ func (this *LiteralNumber) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *LiteralNumber) Dependencies() ExpressionList

+ func (this *LiteralNumber) EquivalentTo(t Expression) bool

+ func (this *LiteralNumber) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *LiteralNumber) String() string

+ type LiteralObject struct

+ Type string

+ Val map[string]Expression

+ func NewLiteralObject(val map[string]Expression) *LiteralObject

+ func (this *LiteralObject) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *LiteralObject) Dependencies() ExpressionList

+ func (this *LiteralObject) EquivalentTo(t Expression) bool

+ func (this *LiteralObject) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *LiteralObject) String() string

+ type LiteralString struct

+ Type string

+ Val string

+ func NewLiteralString(val string) *LiteralString

+ func (this *LiteralString) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *LiteralString) Dependencies() ExpressionList

+ func (this *LiteralString) EquivalentTo(t Expression) bool

+ func (this *LiteralString) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *LiteralString) String() string

+ type ModuloOperator struct

+ Type string

+ func NewModuloOperator(left, right Expression) *ModuloOperator

+ func (this *ModuloOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *ModuloOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type MultiplyOperator struct

+ Type string

+ func NewMultiplyOperator(left, right Expression) *MultiplyOperator

+ func (this *MultiplyOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *MultiplyOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type NaryOperator struct

+ Operands ExpressionList

+ func (this *NaryOperator) Dependencies() ExpressionList

+ func (this *NaryOperator) EquivalentTo(t Expression) bool

+ func (this *NaryOperator) GetOperands() ExpressionList

+ func (this *NaryOperator) Operator() string

+ func (this *NaryOperator) SetOperand(i int, operand Expression)

+ func (this *NaryOperator) SetOperands(operands ExpressionList)

+ func (this *NaryOperator) String() string

+ type NaryOperatorExpression interface

+ GetOperands func() ExpressionList

+ SetOperand func(int, Expression)

+ SetOperands func(ExpressionList)

+ type NotEqualToOperator struct

+ Type string

+ func NewNotEqualToOperator(left, right Expression) *NotEqualToOperator

+ func (this *NotEqualToOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *NotEqualToOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type NotLikeOperator struct

+ Type string

+ func NewNotLikeOperator(left, right Expression) *NotLikeOperator

+ func (this *NotLikeOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *NotLikeOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type NotOperator struct

+ Type string

+ func NewNotOperator(operand Expression) *NotOperator

+ func (this *NotOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *NotOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type OperatorExpression interface

+ Operator func() string

+ type OrOperator struct

+ Type string

+ func NewOrOperator(operands ExpressionList) *OrOperator

+ func (this *OrOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *OrOperator) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ type PlusOperator struct

+ Type string

+ func NewPlusOperator(left, right Expression) *PlusOperator

+ func (this *PlusOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *PlusOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type PrefixUnaryOperator struct

+ func (this *PrefixUnaryOperator) String() string

+ type Property struct

+ Path string

+ Type string

+ func NewProperty(path string) *Property

+ func (this *Property) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *Property) Dependencies() ExpressionList

+ func (this *Property) EquivalentTo(t Expression) bool

+ func (this *Property) Evaluate(item *dparval.Value) (*dparval.Value, error)

+ func (this *Property) String() string

+ type ResultExpression struct

+ As string

+ Expr Expression

+ Star bool

+ func NewDotStarResultExpression(expr Expression) *ResultExpression

+ func NewResultExpression(expr Expression) *ResultExpression

+ func NewResultExpressionWithAlias(expr Expression, as string) *ResultExpression

+ func NewStarResultExpression() *ResultExpression

+ type ResultExpressionList []*ResultExpression

+ func (this ResultExpressionList) AssignDefaultNames(namesInUse []string) error

+ func (this ResultExpressionList) CheckForDuplicateAliases() ([]string, error)

+ func (this ResultExpressionList) ContainsAggregateFunctionCall() bool

+ func (this ResultExpressionList) ExpressionList() ExpressionList

+ func (this ResultExpressionList) Simplify() error

+ func (this ResultExpressionList) String() string

+ func (this ResultExpressionList) Validate() error

+ func (this ResultExpressionList) VerifyAllAggregateFunctionsOrInThisList(groupBy ExpressionList) error

+ func (this ResultExpressionList) VerifyFormalNotation(forbiddenAliases []string, aliases []string, defaultAlias string) error

+ type SelectStatement struct

+ Distinct bool

+ ExplainOnly bool

+ From *From

+ GroupBy ExpressionList

+ Having Expression

+ Limit int

+ Offset int

+ OrderBy SortExpressionList

+ Select ResultExpressionList

+ Where Expression

+ func NewSelectStatement() *SelectStatement

+ func (this *SelectStatement) GetAggregateReferences() ExpressionList

+ func (this *SelectStatement) GetExplicitProjectionAliases() []string

+ func (this *SelectStatement) GetFrom() *From

+ func (this *SelectStatement) GetFromAliases() []string

+ func (this *SelectStatement) GetGroupBy() ExpressionList

+ func (this *SelectStatement) GetHaving() Expression

+ func (this *SelectStatement) GetLimit() int

+ func (this *SelectStatement) GetOffset() int

+ func (this *SelectStatement) GetOrderBy() SortExpressionList

+ func (this *SelectStatement) GetResultExpressionList() ResultExpressionList

+ func (this *SelectStatement) GetWhere() Expression

+ func (this *SelectStatement) IsAggregate() bool

+ func (this *SelectStatement) IsDistinct() bool

+ func (this *SelectStatement) IsExplainOnly() bool

+ func (this *SelectStatement) SetExplainOnly(explainOnly bool)

+ func (this *SelectStatement) Simplify() error

+ func (this *SelectStatement) VerifySemantics() error

+ type SortExpression struct

+ Ascending bool

+ Expr Expression

+ func NewSortExpression(expr Expression, asc bool) *SortExpression

+ type SortExpressionList []*SortExpression

+ func (this SortExpressionList) Simplify() error

+ func (this SortExpressionList) String() string

+ func (this SortExpressionList) Validate() error

+ func (this SortExpressionList) VerifyAllAggregateFunctionsOrInThisList(groupBy ExpressionList) error

+ func (this SortExpressionList) VerifyAllEquivalentToThisList(exprs ExpressionList) error

+ func (this SortExpressionList) VerifyFormalNotation(forbiddenAliases []string, aliases []string, defaultAlias string) error

+ type Statement interface

+ IsExplainOnly func() bool

+ SetExplainOnly func(bool)

+ Simplify func() error

+ VerifySemantics func() error

+ type StringConcatenateOperator struct

+ Type string

+ func NewStringConcatenateOperator(left, right Expression) *StringConcatenateOperator

+ func (this *StringConcatenateOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *StringConcatenateOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type SubtractOperator struct

+ Type string

+ func NewSubtractOperator(left, right Expression) *SubtractOperator

+ func (this *SubtractOperator) Accept(ev ExpressionVisitor) (Expression, error)

+ func (this *SubtractOperator) Evaluate(context *dparval.Value) (*dparval.Value, error)

+ type TypeMismatch struct

+ func (this *TypeMismatch) Error() string

+ type UnaryOperator struct

+ Operand Expression

+ func (this *UnaryOperator) Dependencies() ExpressionList

+ func (this *UnaryOperator) EquivalentTo(t Expression) bool

+ func (this *UnaryOperator) EvaluateFlagMissing(context *dparval.Value) (*dparval.Value, bool, error)

+ func (this *UnaryOperator) EvaluateRequireNumber(context *dparval.Value) (float64, bool, error)

+ func (this *UnaryOperator) GetOperand() Expression

+ func (this *UnaryOperator) Operator() string

+ func (this *UnaryOperator) SetOperand(operand Expression)

+ func (this *UnaryOperator) String() string

+ type UnaryOperatorExpression interface

+ GetOperand func() Expression

+ SetOperand func(Expression)

+ type WhenThen struct

+ Then Expression

+ When Expression

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