functions

package

Go to main page

Versions in this module

v0

v0.10.3

Aug 29, 2025

Changes in this version

+ const FirstValueStr

+ const PostAggregationStr

+ func IsAggregatorFunction(name string) bool

+ func Validate(name string) error

type AggregateType

+ const FirstValue

+ const PostAggregation

type AggregatorFunction

+ func CreateParameterizedAggregator(name string, args []interface{}) (AggregatorFunction, error)

type BaseFunction

+ func (bf *BaseFunction) GetMaxArgs() int

+ func (bf *BaseFunction) GetMinArgs() int

type Function

+ GetMaxArgs func() int

+ GetMinArgs func() int

type LeadFunction

+ func (f *LeadFunction) Init(args []interface{}) error

type NthValueFunction

+ func (f *NthValueFunction) Init(args []interface{}) error

+ type ParameterizedFunction interface

+ Init func(args []interface{}) error

v0.10.2

Aug 8, 2025

Changes in this version

type BaseFunction

+ func NewBaseFunctionWithAliases(name string, fnType FunctionType, category, description string, ...) *BaseFunction

+ func (bf *BaseFunction) GetAliases() []string

type Function

+ GetAliases func() []string

type StdDevFunction

+ func (f *StdDevFunction) Add(value interface{})

+ func (f *StdDevFunction) Clone() AggregatorFunction

+ func (f *StdDevFunction) New() AggregatorFunction

+ func (f *StdDevFunction) Reset()

+ func (f *StdDevFunction) Result() interface{}

type StdDevSFunction

+ func (f *StdDevSFunction) Add(value interface{})

+ func (f *StdDevSFunction) Clone() AggregatorFunction

+ func (f *StdDevSFunction) New() AggregatorFunction

+ func (f *StdDevSFunction) Reset()

+ func (f *StdDevSFunction) Result() interface{}

type VarFunction

+ func (f *VarFunction) Add(value interface{})

+ func (f *VarFunction) Clone() AggregatorFunction

+ func (f *VarFunction) New() AggregatorFunction

+ func (f *VarFunction) Reset()

+ func (f *VarFunction) Result() interface{}

type VarSFunction

+ func (f *VarSFunction) Add(value interface{})

+ func (f *VarSFunction) Clone() AggregatorFunction

+ func (f *VarSFunction) New() AggregatorFunction

+ func (f *VarSFunction) Reset()

+ func (f *VarSFunction) Result() interface{}

v0.10.1

Jul 30, 2025

Changes in this version

type ExprBridge

+ func (bridge *ExprBridge) ContainsBacktickIdentifiers(expression string) bool

+ func (bridge *ExprBridge) PreprocessBacktickIdentifiers(expression string) (string, error)

v0.10.0

Jul 27, 2025

Changes in this version

+ const AvgStr

+ const ChangedColStr

+ const CollectStr

+ const CountStr

+ const DeduplicateStr

+ const ExpressionStr

+ const HadChangedStr

+ const LagStr

+ const LastValueStr

+ const LatestStr

+ const MaxStr

+ const MedianStr

+ const MergeAggStr

+ const MinStr

+ const PercentileStr

+ const StdDevSStr

+ const StdDevStr

+ const StdStr

+ const SumStr

+ const VarSStr

+ const VarStr

+ const WindowEndStr

+ const WindowStartStr

+ func CreateAnalyticalAggregatorFromFunctions(funcType string) interface

+ func CreateBuiltinAggregatorFromFunctions(aggType string) interface

+ func EvaluateWithBridge(expression string, data map[string]interface{}) (interface{}, error)

+ func Execute(name string, ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func GetAggregatorAdapter(name string) (func() interface{}, bool)

+ func GetAllAvailableFunctions() map[string]interface

+ func GetAnalyticalAdapter(name string) (func() *AnalyticalAdapter, bool)

+ func IsUnnestResult(value interface{}) bool

+ func ListAll() map[string]Function

+ func ProcessUnnestResult(value interface{}) []map[string]interface

+ func Register(fn Function) error

+ func RegisterAggregatorAdapter(name string) error

+ func RegisterAnalyticalAdapter(name string) error

+ func RegisterCustomFunction(name string, fnType FunctionType, category, description string, ...) error

+ func RegisterCustomFunctions()

+ func RegisterLegacyAggregator(name string, constructor func() LegacyAggregatorFunction)

+ func Unregister(name string) bool

+ type AbsFunction struct

+ func NewAbsFunction() *AbsFunction

+ func (f *AbsFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *AbsFunction) Validate(args []interface{}) error

+ type AcosFunction struct

+ func NewAcosFunction() *AcosFunction

+ func (f *AcosFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *AcosFunction) Validate(args []interface{}) error

+ type AggregateType string

+ const Avg

+ const ChangedCol

+ const Collect

+ const Count

+ const Deduplicate

+ const Expression

+ const HadChanged

+ const Lag

+ const LastValue

+ const Latest

+ const Max

+ const Median

+ const MergeAgg

+ const Min

+ const Percentile

+ const StdDev

+ const StdDevS

+ const Sum

+ const Var

+ const VarS

+ const WindowEnd

+ const WindowStart

+ type AggregatorAdapter struct

+ func NewAggregatorAdapter(name string) (*AggregatorAdapter, error)

+ func (a *AggregatorAdapter) Add(value interface{})

+ func (a *AggregatorAdapter) GetFunctionName() string

+ func (a *AggregatorAdapter) New() interface{}

+ func (a *AggregatorAdapter) Result() interface{}

+ type AggregatorFunction interface

+ Add func(value interface{})

+ Clone func() AggregatorFunction

+ New func() AggregatorFunction

+ Reset func()

+ Result func() interface{}

+ func CreateAggregator(name string) (AggregatorFunction, error)

+ type AnalyticalAdapter struct

+ func CreateAnalyticalFromFunctions(funcType string) *AnalyticalAdapter

+ func NewAnalyticalAdapter(name string) (*AnalyticalAdapter, error)

+ func (a *AnalyticalAdapter) Clone() *AnalyticalAdapter

+ func (a *AnalyticalAdapter) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (a *AnalyticalAdapter) Reset()

+ type AnalyticalAggregatorAdapter struct

+ func NewAnalyticalAggregatorAdapter(name string) (*AnalyticalAggregatorAdapter, error)

+ func (a *AnalyticalAggregatorAdapter) Add(value interface{})

+ func (a *AnalyticalAggregatorAdapter) New() interface{}

+ func (a *AnalyticalAggregatorAdapter) Result() interface{}

+ type AnalyticalAggregatorWrapper struct

+ func (w *AnalyticalAggregatorWrapper) Add(value interface{})

+ func (w *AnalyticalAggregatorWrapper) New() LegacyAggregatorFunction

+ func (w *AnalyticalAggregatorWrapper) Result() interface{}

+ type AnalyticalFunction interface

+ func CreateAnalytical(name string) (AnalyticalFunction, error)

+ type ArrayContainsFunction struct

+ func NewArrayContainsFunction() *ArrayContainsFunction

+ func (f *ArrayContainsFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ArrayContainsFunction) Validate(args []interface{}) error

+ type ArrayDistinctFunction struct

+ func NewArrayDistinctFunction() *ArrayDistinctFunction

+ func (f *ArrayDistinctFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ArrayDistinctFunction) Validate(args []interface{}) error

+ type ArrayExceptFunction struct

+ func NewArrayExceptFunction() *ArrayExceptFunction

+ func (f *ArrayExceptFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ArrayExceptFunction) Validate(args []interface{}) error

+ type ArrayIntersectFunction struct

+ func NewArrayIntersectFunction() *ArrayIntersectFunction

+ func (f *ArrayIntersectFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ArrayIntersectFunction) Validate(args []interface{}) error

+ type ArrayLengthFunction struct

+ func NewArrayLengthFunction() *ArrayLengthFunction

+ func (f *ArrayLengthFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ArrayLengthFunction) Validate(args []interface{}) error

+ type ArrayPositionFunction struct

+ func NewArrayPositionFunction() *ArrayPositionFunction

+ func (f *ArrayPositionFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ArrayPositionFunction) Validate(args []interface{}) error

+ type ArrayRemoveFunction struct

+ func NewArrayRemoveFunction() *ArrayRemoveFunction

+ func (f *ArrayRemoveFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ArrayRemoveFunction) Validate(args []interface{}) error

+ type ArrayUnionFunction struct

+ func NewArrayUnionFunction() *ArrayUnionFunction

+ func (f *ArrayUnionFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ArrayUnionFunction) Validate(args []interface{}) error

+ type AsinFunction struct

+ func NewAsinFunction() *AsinFunction

+ func (f *AsinFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *AsinFunction) Validate(args []interface{}) error

+ type Atan2Function struct

+ func NewAtan2Function() *Atan2Function

+ func (f *Atan2Function) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *Atan2Function) Validate(args []interface{}) error

+ type AtanFunction struct

+ func NewAtanFunction() *AtanFunction

+ func (f *AtanFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *AtanFunction) Validate(args []interface{}) error

+ type AvgFunction struct

+ func NewAvgFunction() *AvgFunction

+ func (f *AvgFunction) Add(value interface{})

+ func (f *AvgFunction) Clone() AggregatorFunction

+ func (f *AvgFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *AvgFunction) New() AggregatorFunction

+ func (f *AvgFunction) Reset()

+ func (f *AvgFunction) Result() interface{}

+ func (f *AvgFunction) Validate(args []interface{}) error

+ type BaseFunction struct

+ func NewBaseFunction(name string, fnType FunctionType, category, description string, ...) *BaseFunction

+ func (bf *BaseFunction) GetCategory() string

+ func (bf *BaseFunction) GetDescription() string

+ func (bf *BaseFunction) GetName() string

+ func (bf *BaseFunction) GetType() FunctionType

+ func (bf *BaseFunction) ValidateArgCount(args []interface{}) error

+ type BitAndFunction struct

+ func NewBitAndFunction() *BitAndFunction

+ func (f *BitAndFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *BitAndFunction) Validate(args []interface{}) error

+ type BitNotFunction struct

+ func NewBitNotFunction() *BitNotFunction

+ func (f *BitNotFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *BitNotFunction) Validate(args []interface{}) error

+ type BitOrFunction struct

+ func NewBitOrFunction() *BitOrFunction

+ func (f *BitOrFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *BitOrFunction) Validate(args []interface{}) error

+ type BitXorFunction struct

+ func NewBitXorFunction() *BitXorFunction

+ func (f *BitXorFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *BitXorFunction) Validate(args []interface{}) error

+ type CaseWhenFunction struct

+ func NewCaseWhenFunction() *CaseWhenFunction

+ func (f *CaseWhenFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *CaseWhenFunction) Validate(args []interface{}) error

+ type CastFunction struct

+ func NewCastFunction() *CastFunction

+ func (f *CastFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *CastFunction) Validate(args []interface{}) error

+ type CeilingFunction struct

+ func NewCeilingFunction() *CeilingFunction

+ func (f *CeilingFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *CeilingFunction) Validate(args []interface{}) error

+ type ChangedColFunction struct

+ PreviousValues map[string]interface{}

+ func NewChangedColFunction() *ChangedColFunction

+ func (f *ChangedColFunction) Add(value interface{})

+ func (f *ChangedColFunction) Clone() AggregatorFunction

+ func (f *ChangedColFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ChangedColFunction) New() AggregatorFunction

+ func (f *ChangedColFunction) Reset()

+ func (f *ChangedColFunction) Result() interface{}

+ func (f *ChangedColFunction) Validate(args []interface{}) error

+ type ChrFunction struct

+ func NewChrFunction() *ChrFunction

+ func (f *ChrFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ChrFunction) Validate(args []interface{}) error

+ type CoalesceFunction struct

+ func NewCoalesceFunction() *CoalesceFunction

+ func (f *CoalesceFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *CoalesceFunction) Validate(args []interface{}) error

+ type CollectAggregatorFunction struct

+ func NewCollectAggregatorFunction() *CollectAggregatorFunction

+ func (f *CollectAggregatorFunction) Add(value interface{})

+ func (f *CollectAggregatorFunction) Clone() AggregatorFunction

+ func (f *CollectAggregatorFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *CollectAggregatorFunction) New() AggregatorFunction

+ func (f *CollectAggregatorFunction) Reset()

+ func (f *CollectAggregatorFunction) Result() interface{}

+ func (f *CollectAggregatorFunction) Validate(args []interface{}) error

+ type CollectFunction struct

+ func NewCollectFunction() *CollectFunction

+ func (f *CollectFunction) Add(value interface{})

+ func (f *CollectFunction) Clone() AggregatorFunction

+ func (f *CollectFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *CollectFunction) New() AggregatorFunction

+ func (f *CollectFunction) Reset()

+ func (f *CollectFunction) Result() interface{}

+ func (f *CollectFunction) Validate(args []interface{}) error

+ type ConcatFunction struct

+ func NewConcatFunction() *ConcatFunction

+ func (f *ConcatFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ConcatFunction) Validate(args []interface{}) error

+ type ContextAggregator interface

+ GetContextKey func() string

+ type ConvertTzFunction struct

+ func NewConvertTzFunction() *ConvertTzFunction

+ func (f *ConvertTzFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ConvertTzFunction) Validate(args []interface{}) error

+ type CosFunction struct

+ func NewCosFunction() *CosFunction

+ func (f *CosFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *CosFunction) Validate(args []interface{}) error

+ type CoshFunction struct

+ func NewCoshFunction() *CoshFunction

+ func (f *CoshFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *CoshFunction) Validate(args []interface{}) error

+ type CountFunction struct

+ func NewCountFunction() *CountFunction

+ func (f *CountFunction) Add(value interface{})

+ func (f *CountFunction) Clone() AggregatorFunction

+ func (f *CountFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *CountFunction) New() AggregatorFunction

+ func (f *CountFunction) Reset()

+ func (f *CountFunction) Result() interface{}

+ func (f *CountFunction) Validate(args []interface{}) error

+ type CurrentDateFunction struct

+ func NewCurrentDateFunction() *CurrentDateFunction

+ func (f *CurrentDateFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *CurrentDateFunction) Validate(args []interface{}) error

+ type CurrentTimeFunction struct

+ func NewCurrentTimeFunction() *CurrentTimeFunction

+ func (f *CurrentTimeFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *CurrentTimeFunction) Validate(args []interface{}) error

+ type CustomFunction struct

+ func (f *CustomFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *CustomFunction) Validate(args []interface{}) error

+ type CustomGeometricMeanFunction struct

+ func NewCustomGeometricMeanFunction() *CustomGeometricMeanFunction

+ func (f *CustomGeometricMeanFunction) Add(value interface{})

+ func (f *CustomGeometricMeanFunction) Clone() AggregatorFunction

+ func (f *CustomGeometricMeanFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *CustomGeometricMeanFunction) New() AggregatorFunction

+ func (f *CustomGeometricMeanFunction) Reset()

+ func (f *CustomGeometricMeanFunction) Result() interface{}

+ func (f *CustomGeometricMeanFunction) Validate(args []interface{}) error

+ type CustomMovingAverageFunction struct

+ func NewCustomMovingAverageFunction(windowSize int) *CustomMovingAverageFunction

+ func (f *CustomMovingAverageFunction) Add(value interface{})

+ func (f *CustomMovingAverageFunction) Clone() AggregatorFunction

+ func (f *CustomMovingAverageFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *CustomMovingAverageFunction) New() AggregatorFunction

+ func (f *CustomMovingAverageFunction) Reset()

+ func (f *CustomMovingAverageFunction) Result() interface{}

+ func (f *CustomMovingAverageFunction) Validate(args []interface{}) error

+ type CustomProductFunction struct

+ func NewCustomProductFunction() *CustomProductFunction

+ func (f *CustomProductFunction) Add(value interface{})

+ func (f *CustomProductFunction) Clone() AggregatorFunction

+ func (f *CustomProductFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *CustomProductFunction) New() AggregatorFunction

+ func (f *CustomProductFunction) Reset()

+ func (f *CustomProductFunction) Result() interface{}

+ func (f *CustomProductFunction) Validate(args []interface{}) error

+ type DateAddFunction struct

+ func NewDateAddFunction() *DateAddFunction

+ func (f *DateAddFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *DateAddFunction) Validate(args []interface{}) error

+ type DateDiffFunction struct

+ func NewDateDiffFunction() *DateDiffFunction

+ func (f *DateDiffFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *DateDiffFunction) Validate(args []interface{}) error

+ type DateFormatFunction struct

+ func NewDateFormatFunction() *DateFormatFunction

+ func (f *DateFormatFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *DateFormatFunction) Validate(args []interface{}) error

+ type DateParseFunction struct

+ func NewDateParseFunction() *DateParseFunction

+ func (f *DateParseFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *DateParseFunction) Validate(args []interface{}) error

+ type DateSubFunction struct

+ func NewDateSubFunction() *DateSubFunction

+ func (f *DateSubFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *DateSubFunction) Validate(args []interface{}) error

+ type DayFunction struct

+ func NewDayFunction() *DayFunction

+ func (f *DayFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *DayFunction) Validate(args []interface{}) error

+ type DayOfWeekFunction struct

+ func NewDayOfWeekFunction() *DayOfWeekFunction

+ func (f *DayOfWeekFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *DayOfWeekFunction) Validate(args []interface{}) error

+ type DayOfYearFunction struct

+ func NewDayOfYearFunction() *DayOfYearFunction

+ func (f *DayOfYearFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *DayOfYearFunction) Validate(args []interface{}) error

+ type Dec2HexFunction struct

+ func NewDec2HexFunction() *Dec2HexFunction

+ func (f *Dec2HexFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *Dec2HexFunction) Validate(args []interface{}) error

+ type DecodeFunction struct

+ func NewDecodeFunction() *DecodeFunction

+ func (f *DecodeFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *DecodeFunction) Validate(args []interface{}) error

+ type DeduplicateAggregatorFunction struct

+ func NewDeduplicateAggregatorFunction() *DeduplicateAggregatorFunction

+ func (f *DeduplicateAggregatorFunction) Add(value interface{})

+ func (f *DeduplicateAggregatorFunction) Clone() AggregatorFunction

+ func (f *DeduplicateAggregatorFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *DeduplicateAggregatorFunction) New() AggregatorFunction

+ func (f *DeduplicateAggregatorFunction) Reset()

+ func (f *DeduplicateAggregatorFunction) Result() interface{}

+ func (f *DeduplicateAggregatorFunction) Validate(args []interface{}) error

+ type DeduplicateFunction struct

+ func NewDeduplicateFunction() *DeduplicateFunction

+ func (f *DeduplicateFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *DeduplicateFunction) Validate(args []interface{}) error

+ type EncodeFunction struct

+ func NewEncodeFunction() *EncodeFunction

+ func (f *EncodeFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *EncodeFunction) Validate(args []interface{}) error

+ type EndswithFunction struct

+ func NewEndswithFunction() *EndswithFunction

+ func (f *EndswithFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *EndswithFunction) Validate(args []interface{}) error

+ type ExpFunction struct

+ func NewExpFunction() *ExpFunction

+ func (f *ExpFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ExpFunction) Validate(args []interface{}) error

+ type ExprBridge struct

+ func GetExprBridge() *ExprBridge

+ func NewExprBridge() *ExprBridge

+ func (bridge *ExprBridge) CompileExpressionWithStreamSQLFunctions(expression string, dataType interface{}) (*vm.Program, error)

+ func (bridge *ExprBridge) ContainsIsNullOperator(expression string) bool

+ func (bridge *ExprBridge) ContainsLikeOperator(expression string) bool

+ func (bridge *ExprBridge) CreateEnhancedExprEnvironment(data map[string]interface{}) map[string]interface{}

+ func (bridge *ExprBridge) EvaluateExpression(expression string, data map[string]interface{}) (interface{}, error)

+ func (bridge *ExprBridge) GetFunctionInfo() map[string]interface{}

+ func (bridge *ExprBridge) IsExprLangFunction(name string) bool

+ func (bridge *ExprBridge) PreprocessIsNullExpression(expression string) (string, error)

+ func (bridge *ExprBridge) PreprocessLikeExpression(expression string) (string, error)

+ func (bridge *ExprBridge) RegisterStreamSQLFunctionsToExpr() []expr.Option

+ func (bridge *ExprBridge) ResolveFunction(name string) (interface{}, bool, string)

+ type ExprFunction struct

+ func NewExprFunction() *ExprFunction

+ func (f *ExprFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ExprFunction) Validate(args []interface{}) error

+ type ExpressionAggregatorFunction struct

+ func NewExpressionAggregatorFunction() *ExpressionAggregatorFunction

+ func (f *ExpressionAggregatorFunction) Add(value interface{})

+ func (f *ExpressionAggregatorFunction) Clone() AggregatorFunction

+ func (f *ExpressionAggregatorFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ExpressionAggregatorFunction) New() AggregatorFunction

+ func (f *ExpressionAggregatorFunction) Reset()

+ func (f *ExpressionAggregatorFunction) Result() interface{}

+ func (f *ExpressionAggregatorFunction) Validate(args []interface{}) error

+ type ExpressionFunction struct

+ func NewExpressionFunction() *ExpressionFunction

+ func (f *ExpressionFunction) Add(value interface{})

+ func (f *ExpressionFunction) Clone() AggregatorFunction

+ func (f *ExpressionFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ExpressionFunction) New() AggregatorFunction

+ func (f *ExpressionFunction) Reset()

+ func (f *ExpressionFunction) Result() interface{}

+ func (f *ExpressionFunction) Validate(args []interface{}) error

+ type ExtractFunction struct

+ func NewExtractFunction() *ExtractFunction

+ func (f *ExtractFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ExtractFunction) Validate(args []interface{}) error

+ type FirstValueFunction struct

+ func NewFirstValueFunction() *FirstValueFunction

+ func (f *FirstValueFunction) Add(value interface{})

+ func (f *FirstValueFunction) Clone() AggregatorFunction

+ func (f *FirstValueFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *FirstValueFunction) New() AggregatorFunction

+ func (f *FirstValueFunction) Reset()

+ func (f *FirstValueFunction) Result() interface{}

+ func (f *FirstValueFunction) Validate(args []interface{}) error

+ type FloorFunction struct

+ func NewFloorFunction() *FloorFunction

+ func (f *FloorFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *FloorFunction) Validate(args []interface{}) error

+ type FormatFunction struct

+ func NewFormatFunction() *FormatFunction

+ func (f *FormatFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *FormatFunction) Validate(args []interface{}) error

+ type FromJsonFunction struct

+ func NewFromJsonFunction() *FromJsonFunction

+ func (f *FromJsonFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *FromJsonFunction) Validate(args []interface{}) error

+ type FromUnixtimeFunction struct

+ func NewFromUnixtimeFunction() *FromUnixtimeFunction

+ func (f *FromUnixtimeFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *FromUnixtimeFunction) Validate(args []interface{}) error

+ type Function interface

+ Execute func(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ GetCategory func() string

+ GetDescription func() string

+ GetName func() string

+ GetType func() FunctionType

+ Validate func(args []interface{}) error

+ func Get(name string) (Function, bool)

+ func GetByType(fnType FunctionType) []Function

+ type FunctionAggregatorWrapper struct

+ func (w *FunctionAggregatorWrapper) Add(value interface{})

+ func (w *FunctionAggregatorWrapper) GetContextKey() string

+ func (w *FunctionAggregatorWrapper) New() LegacyAggregatorFunction

+ func (w *FunctionAggregatorWrapper) Result() interface{}

+ type FunctionContext struct

+ Data map[string]interface{}

+ Extra map[string]interface{}

+ WindowInfo *WindowInfo

+ type FunctionRegistry struct

+ func NewFunctionRegistry() *FunctionRegistry

+ func (r *FunctionRegistry) Get(name string) (Function, bool)

+ func (r *FunctionRegistry) GetByType(fnType FunctionType) []Function

+ func (r *FunctionRegistry) ListAll() map[string]Function

+ func (r *FunctionRegistry) Register(fn Function) error

+ func (r *FunctionRegistry) Unregister(name string) bool

+ type FunctionType string

+ const TypeAggregation

+ const TypeAnalytical

+ const TypeConversion

+ const TypeCustom

+ const TypeDateTime

+ const TypeMath

+ const TypeString

+ const TypeWindow

+ type GreatestFunction struct

+ func NewGreatestFunction() *GreatestFunction

+ func (f *GreatestFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *GreatestFunction) Validate(args []interface{}) error

+ type HadChangedFunction struct

+ IsSet bool

+ PreviousValue interface{}

+ func NewHadChangedFunction() *HadChangedFunction

+ func (f *HadChangedFunction) Add(value interface{})

+ func (f *HadChangedFunction) Clone() AggregatorFunction

+ func (f *HadChangedFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *HadChangedFunction) New() AggregatorFunction

+ func (f *HadChangedFunction) Reset()

+ func (f *HadChangedFunction) Result() interface{}

+ func (f *HadChangedFunction) Validate(args []interface{}) error

+ type Hex2DecFunction struct

+ func NewHex2DecFunction() *Hex2DecFunction

+ func (f *Hex2DecFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *Hex2DecFunction) Validate(args []interface{}) error

+ type HourFunction struct

+ func NewHourFunction() *HourFunction

+ func (f *HourFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *HourFunction) Validate(args []interface{}) error

+ type IfNullFunction struct

+ func NewIfNullFunction() *IfNullFunction

+ func (f *IfNullFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *IfNullFunction) Validate(args []interface{}) error

+ type IndexofFunction struct

+ func NewIndexofFunction() *IndexofFunction

+ func (f *IndexofFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *IndexofFunction) Validate(args []interface{}) error

+ type IsArrayFunction struct

+ func NewIsArrayFunction() *IsArrayFunction

+ func (f *IsArrayFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *IsArrayFunction) Validate(args []interface{}) error

+ type IsBoolFunction struct

+ func NewIsBoolFunction() *IsBoolFunction

+ func (f *IsBoolFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *IsBoolFunction) Validate(args []interface{}) error

+ type IsNotNullFunction struct

+ func NewIsNotNullFunction() *IsNotNullFunction

+ func (f *IsNotNullFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *IsNotNullFunction) Validate(args []interface{}) error

+ type IsNullFunction struct

+ func NewIsNullFunction() *IsNullFunction

+ func (f *IsNullFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *IsNullFunction) Validate(args []interface{}) error

+ type IsNumericFunction struct

+ func NewIsNumericFunction() *IsNumericFunction

+ func (f *IsNumericFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *IsNumericFunction) Validate(args []interface{}) error

+ type IsObjectFunction struct

+ func NewIsObjectFunction() *IsObjectFunction

+ func (f *IsObjectFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *IsObjectFunction) Validate(args []interface{}) error

+ type IsStringFunction struct

+ func NewIsStringFunction() *IsStringFunction

+ func (f *IsStringFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *IsStringFunction) Validate(args []interface{}) error

+ type JsonExtractFunction struct

+ func NewJsonExtractFunction() *JsonExtractFunction

+ func (f *JsonExtractFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *JsonExtractFunction) Validate(args []interface{}) error

+ type JsonLengthFunction struct

+ func NewJsonLengthFunction() *JsonLengthFunction

+ func (f *JsonLengthFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *JsonLengthFunction) Validate(args []interface{}) error

+ type JsonTypeFunction struct

+ func NewJsonTypeFunction() *JsonTypeFunction

+ func (f *JsonTypeFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *JsonTypeFunction) Validate(args []interface{}) error

+ type JsonValidFunction struct

+ func NewJsonValidFunction() *JsonValidFunction

+ func (f *JsonValidFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *JsonValidFunction) Validate(args []interface{}) error

+ type LagFunction struct

+ DefaultValue interface{}

+ Offset int

+ PreviousValues []interface{}

+ func NewLagFunction() *LagFunction

+ func (f *LagFunction) Add(value interface{})

+ func (f *LagFunction) Clone() AggregatorFunction

+ func (f *LagFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *LagFunction) New() AggregatorFunction

+ func (f *LagFunction) Reset()

+ func (f *LagFunction) Result() interface{}

+ func (f *LagFunction) Validate(args []interface{}) error

+ type LastValueAggregatorFunction struct

+ func NewLastValueAggregatorFunction() *LastValueAggregatorFunction

+ func (f *LastValueAggregatorFunction) Add(value interface{})

+ func (f *LastValueAggregatorFunction) Clone() AggregatorFunction

+ func (f *LastValueAggregatorFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *LastValueAggregatorFunction) New() AggregatorFunction

+ func (f *LastValueAggregatorFunction) Reset()

+ func (f *LastValueAggregatorFunction) Result() interface{}

+ func (f *LastValueAggregatorFunction) Validate(args []interface{}) error

+ type LastValueFunction struct

+ func NewLastValueFunction() *LastValueFunction

+ func (f *LastValueFunction) Add(value interface{})

+ func (f *LastValueFunction) Clone() AggregatorFunction

+ func (f *LastValueFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *LastValueFunction) New() AggregatorFunction

+ func (f *LastValueFunction) Reset()

+ func (f *LastValueFunction) Result() interface{}

+ func (f *LastValueFunction) Validate(args []interface{}) error

+ type LatestFunction struct

+ LatestValue interface{}

+ func NewLatestFunction() *LatestFunction

+ func (f *LatestFunction) Add(value interface{})

+ func (f *LatestFunction) Clone() AggregatorFunction

+ func (f *LatestFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *LatestFunction) New() AggregatorFunction

+ func (f *LatestFunction) Reset()

+ func (f *LatestFunction) Result() interface{}

+ func (f *LatestFunction) Validate(args []interface{}) error

+ type LeadFunction struct

+ func NewLeadFunction() *LeadFunction

+ func (f *LeadFunction) Add(value interface{})

+ func (f *LeadFunction) Clone() AggregatorFunction

+ func (f *LeadFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *LeadFunction) New() AggregatorFunction

+ func (f *LeadFunction) Reset()

+ func (f *LeadFunction) Result() interface{}

+ func (f *LeadFunction) Validate(args []interface{}) error

+ type LeastFunction struct

+ func NewLeastFunction() *LeastFunction

+ func (f *LeastFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *LeastFunction) Validate(args []interface{}) error

+ type LegacyAggregatorFunction interface

+ Add func(value interface{})

+ New func() LegacyAggregatorFunction

+ Result func() interface{}

+ func CreateLegacyAggregator(aggType AggregateType) LegacyAggregatorFunction

+ type LengthFunction struct

+ func NewLengthFunction() *LengthFunction

+ func (f *LengthFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *LengthFunction) Validate(args []interface{}) error

+ type LnFunction struct

+ func NewLnFunction() *LnFunction

+ func (f *LnFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *LnFunction) Validate(args []interface{}) error

+ type Log10Function struct

+ func NewLog10Function() *Log10Function

+ func (f *Log10Function) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *Log10Function) Validate(args []interface{}) error

+ type Log2Function struct

+ func NewLog2Function() *Log2Function

+ func (f *Log2Function) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *Log2Function) Validate(args []interface{}) error

+ type LogFunction struct

+ func NewLogFunction() *LogFunction

+ func (f *LogFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *LogFunction) Validate(args []interface{}) error

+ type LowerFunction struct

+ func NewLowerFunction() *LowerFunction

+ func (f *LowerFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *LowerFunction) Validate(args []interface{}) error

+ type LpadFunction struct

+ func NewLpadFunction() *LpadFunction

+ func (f *LpadFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *LpadFunction) Validate(args []interface{}) error

+ type LtrimFunction struct

+ func NewLtrimFunction() *LtrimFunction

+ func (f *LtrimFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *LtrimFunction) Validate(args []interface{}) error

+ type MaxFunction struct

+ func NewMaxFunction() *MaxFunction

+ func (f *MaxFunction) Add(value interface{})

+ func (f *MaxFunction) Clone() AggregatorFunction

+ func (f *MaxFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *MaxFunction) New() AggregatorFunction

+ func (f *MaxFunction) Reset()

+ func (f *MaxFunction) Result() interface{}

+ func (f *MaxFunction) Validate(args []interface{}) error

+ type Md5Function struct

+ func NewMd5Function() *Md5Function

+ func (f *Md5Function) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *Md5Function) Validate(args []interface{}) error

+ type MedianAggregatorFunction struct

+ func NewMedianAggregatorFunction() *MedianAggregatorFunction

+ func (f *MedianAggregatorFunction) Add(value interface{})

+ func (f *MedianAggregatorFunction) Clone() AggregatorFunction

+ func (f *MedianAggregatorFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *MedianAggregatorFunction) New() AggregatorFunction

+ func (f *MedianAggregatorFunction) Reset()

+ func (f *MedianAggregatorFunction) Result() interface{}

+ func (f *MedianAggregatorFunction) Validate(args []interface{}) error

+ type MedianFunction struct

+ func NewMedianFunction() *MedianFunction

+ func (f *MedianFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *MedianFunction) Validate(args []interface{}) error

+ type MergeAggAggregatorFunction struct

+ func NewMergeAggAggregatorFunction() *MergeAggAggregatorFunction

+ func (f *MergeAggAggregatorFunction) Add(value interface{})

+ func (f *MergeAggAggregatorFunction) Clone() AggregatorFunction

+ func (f *MergeAggAggregatorFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *MergeAggAggregatorFunction) New() AggregatorFunction

+ func (f *MergeAggAggregatorFunction) Reset()

+ func (f *MergeAggAggregatorFunction) Result() interface{}

+ func (f *MergeAggAggregatorFunction) Validate(args []interface{}) error

+ type MergeAggFunction struct

+ func NewMergeAggFunction() *MergeAggFunction

+ func (f *MergeAggFunction) Add(value interface{})

+ func (f *MergeAggFunction) Clone() AggregatorFunction

+ func (f *MergeAggFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *MergeAggFunction) New() AggregatorFunction

+ func (f *MergeAggFunction) Reset()

+ func (f *MergeAggFunction) Result() interface{}

+ func (f *MergeAggFunction) Validate(args []interface{}) error

+ type MinFunction struct

+ func NewMinFunction() *MinFunction

+ func (f *MinFunction) Add(value interface{})

+ func (f *MinFunction) Clone() AggregatorFunction

+ func (f *MinFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *MinFunction) New() AggregatorFunction

+ func (f *MinFunction) Reset()

+ func (f *MinFunction) Result() interface{}

+ func (f *MinFunction) Validate(args []interface{}) error

+ type MinuteFunction struct

+ func NewMinuteFunction() *MinuteFunction

+ func (f *MinuteFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *MinuteFunction) Validate(args []interface{}) error

+ type ModFunction struct

+ func NewModFunction() *ModFunction

+ func (f *ModFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ModFunction) Validate(args []interface{}) error

+ type MonthFunction struct

+ func NewMonthFunction() *MonthFunction

+ func (f *MonthFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *MonthFunction) Validate(args []interface{}) error

+ type NowFunction struct

+ func NewNowFunction() *NowFunction

+ func (f *NowFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *NowFunction) Validate(args []interface{}) error

+ type NthValueFunction struct

+ func NewNthValueFunction() *NthValueFunction

+ func (f *NthValueFunction) Add(value interface{})

+ func (f *NthValueFunction) Clone() AggregatorFunction

+ func (f *NthValueFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *NthValueFunction) New() AggregatorFunction

+ func (f *NthValueFunction) Reset()

+ func (f *NthValueFunction) Result() interface{}

+ func (f *NthValueFunction) Validate(args []interface{}) error

+ type NullIfFunction struct

+ func NewNullIfFunction() *NullIfFunction

+ func (f *NullIfFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *NullIfFunction) Validate(args []interface{}) error

+ type OptimizedStdDevFunction struct

+ func NewOptimizedStdDevFunction() *OptimizedStdDevFunction

+ func (f *OptimizedStdDevFunction) Add(value interface{})

+ func (f *OptimizedStdDevFunction) Clone() AggregatorFunction

+ func (f *OptimizedStdDevFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *OptimizedStdDevFunction) New() AggregatorFunction

+ func (f *OptimizedStdDevFunction) Reset()

+ func (f *OptimizedStdDevFunction) Result() interface{}

+ func (f *OptimizedStdDevFunction) Validate(args []interface{}) error

+ type OptimizedStdDevSFunction struct

+ func NewOptimizedStdDevSFunction() *OptimizedStdDevSFunction

+ func (f *OptimizedStdDevSFunction) Add(value interface{})

+ func (f *OptimizedStdDevSFunction) Clone() AggregatorFunction

+ func (f *OptimizedStdDevSFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *OptimizedStdDevSFunction) New() AggregatorFunction

+ func (f *OptimizedStdDevSFunction) Reset()

+ func (f *OptimizedStdDevSFunction) Result() interface{}

+ func (f *OptimizedStdDevSFunction) Validate(args []interface{}) error

+ type OptimizedVarFunction struct

+ func NewOptimizedVarFunction() *OptimizedVarFunction

+ func (f *OptimizedVarFunction) Add(value interface{})

+ func (f *OptimizedVarFunction) Clone() AggregatorFunction

+ func (f *OptimizedVarFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *OptimizedVarFunction) New() AggregatorFunction

+ func (f *OptimizedVarFunction) Reset()

+ func (f *OptimizedVarFunction) Result() interface{}

+ func (f *OptimizedVarFunction) Validate(args []interface{}) error

+ type OptimizedVarSFunction struct

+ func NewOptimizedVarSFunction() *OptimizedVarSFunction

+ func (f *OptimizedVarSFunction) Add(value interface{})

+ func (f *OptimizedVarSFunction) Clone() AggregatorFunction

+ func (f *OptimizedVarSFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *OptimizedVarSFunction) New() AggregatorFunction

+ func (f *OptimizedVarSFunction) Reset()

+ func (f *OptimizedVarSFunction) Result() interface{}

+ func (f *OptimizedVarSFunction) Validate(args []interface{}) error

+ type PercentileAggregatorFunction struct

+ func NewPercentileAggregatorFunction() *PercentileAggregatorFunction

+ func (f *PercentileAggregatorFunction) Add(value interface{})

+ func (f *PercentileAggregatorFunction) Clone() AggregatorFunction

+ func (f *PercentileAggregatorFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *PercentileAggregatorFunction) New() AggregatorFunction

+ func (f *PercentileAggregatorFunction) Reset()

+ func (f *PercentileAggregatorFunction) Result() interface{}

+ func (f *PercentileAggregatorFunction) Validate(args []interface{}) error

+ type PercentileFunction struct

+ func NewPercentileFunction() *PercentileFunction

+ func (f *PercentileFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *PercentileFunction) Validate(args []interface{}) error

+ type PowerFunction struct

+ func NewPowerFunction() *PowerFunction

+ func (f *PowerFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *PowerFunction) Validate(args []interface{}) error

+ type RandFunction struct

+ func NewRandFunction() *RandFunction

+ func (f *RandFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *RandFunction) Validate(args []interface{}) error

+ type RegexpMatchesFunction struct

+ func NewRegexpMatchesFunction() *RegexpMatchesFunction

+ func (f *RegexpMatchesFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *RegexpMatchesFunction) Validate(args []interface{}) error

+ type RegexpReplaceFunction struct

+ func NewRegexpReplaceFunction() *RegexpReplaceFunction

+ func (f *RegexpReplaceFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *RegexpReplaceFunction) Validate(args []interface{}) error

+ type RegexpSubstringFunction struct

+ func NewRegexpSubstringFunction() *RegexpSubstringFunction

+ func (f *RegexpSubstringFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *RegexpSubstringFunction) Validate(args []interface{}) error

+ type ReplaceFunction struct

+ func NewReplaceFunction() *ReplaceFunction

+ func (f *ReplaceFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ReplaceFunction) Validate(args []interface{}) error

+ type RoundFunction struct

+ func NewRoundFunction() *RoundFunction

+ func (f *RoundFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *RoundFunction) Validate(args []interface{}) error

+ type RowNumberFunction struct

+ CurrentRowNumber int64

+ func NewRowNumberFunction() *RowNumberFunction

+ func (f *RowNumberFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *RowNumberFunction) Reset()

+ func (f *RowNumberFunction) Validate(args []interface{}) error

+ type RpadFunction struct

+ func NewRpadFunction() *RpadFunction

+ func (f *RpadFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *RpadFunction) Validate(args []interface{}) error

+ type RtrimFunction struct

+ func NewRtrimFunction() *RtrimFunction

+ func (f *RtrimFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *RtrimFunction) Validate(args []interface{}) error

+ type SecondFunction struct

+ func NewSecondFunction() *SecondFunction

+ func (f *SecondFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *SecondFunction) Validate(args []interface{}) error

+ type Sha1Function struct

+ func NewSha1Function() *Sha1Function

+ func (f *Sha1Function) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *Sha1Function) Validate(args []interface{}) error

+ type Sha256Function struct

+ func NewSha256Function() *Sha256Function

+ func (f *Sha256Function) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *Sha256Function) Validate(args []interface{}) error

+ type Sha512Function struct

+ func NewSha512Function() *Sha512Function

+ func (f *Sha512Function) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *Sha512Function) Validate(args []interface{}) error

+ type SignFunction struct

+ func NewSignFunction() *SignFunction

+ func (f *SignFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *SignFunction) Validate(args []interface{}) error

+ type SinFunction struct

+ func NewSinFunction() *SinFunction

+ func (f *SinFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *SinFunction) Validate(args []interface{}) error

+ type SinhFunction struct

+ func NewSinhFunction() *SinhFunction

+ func (f *SinhFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *SinhFunction) Validate(args []interface{}) error

+ type SplitFunction struct

+ func NewSplitFunction() *SplitFunction

+ func (f *SplitFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *SplitFunction) Validate(args []interface{}) error

+ type SqrtFunction struct

+ func NewSqrtFunction() *SqrtFunction

+ func (f *SqrtFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *SqrtFunction) Validate(args []interface{}) error

+ type StartswithFunction struct

+ func NewStartswithFunction() *StartswithFunction

+ func (f *StartswithFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *StartswithFunction) Validate(args []interface{}) error

+ type StdDevAggregatorFunction struct

+ func NewStdDevAggregatorFunction() *StdDevAggregatorFunction

+ func (f *StdDevAggregatorFunction) Add(value interface{})

+ func (f *StdDevAggregatorFunction) Clone() AggregatorFunction

+ func (f *StdDevAggregatorFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *StdDevAggregatorFunction) New() AggregatorFunction

+ func (f *StdDevAggregatorFunction) Reset()

+ func (f *StdDevAggregatorFunction) Result() interface{}

+ func (f *StdDevAggregatorFunction) Validate(args []interface{}) error

+ type StdDevFunction struct

+ func NewStdDevFunction() *StdDevFunction

+ func (f *StdDevFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *StdDevFunction) Validate(args []interface{}) error

+ type StdDevSAggregatorFunction struct

+ func NewStdDevSAggregatorFunction() *StdDevSAggregatorFunction

+ func (f *StdDevSAggregatorFunction) Add(value interface{})

+ func (f *StdDevSAggregatorFunction) Clone() AggregatorFunction

+ func (f *StdDevSAggregatorFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *StdDevSAggregatorFunction) New() AggregatorFunction

+ func (f *StdDevSAggregatorFunction) Reset()

+ func (f *StdDevSAggregatorFunction) Result() interface{}

+ func (f *StdDevSAggregatorFunction) Validate(args []interface{}) error

+ type StdDevSFunction struct

+ func NewStdDevSFunction() *StdDevSFunction

+ func (f *StdDevSFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *StdDevSFunction) Validate(args []interface{}) error

+ type SubstringFunction struct

+ func NewSubstringFunction() *SubstringFunction

+ func (f *SubstringFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *SubstringFunction) Validate(args []interface{}) error

+ type SumFunction struct

+ func NewSumFunction() *SumFunction

+ func (f *SumFunction) Add(value interface{})

+ func (f *SumFunction) Clone() AggregatorFunction

+ func (f *SumFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *SumFunction) New() AggregatorFunction

+ func (f *SumFunction) Reset()

+ func (f *SumFunction) Result() interface{}

+ func (f *SumFunction) Validate(args []interface{}) error

+ type TanFunction struct

+ func NewTanFunction() *TanFunction

+ func (f *TanFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *TanFunction) Validate(args []interface{}) error

+ type TanhFunction struct

+ func NewTanhFunction() *TanhFunction

+ func (f *TanhFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *TanhFunction) Validate(args []interface{}) error

+ type ToJsonFunction struct

+ func NewToJsonFunction() *ToJsonFunction

+ func (f *ToJsonFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ToJsonFunction) Validate(args []interface{}) error

+ type ToSecondsFunction struct

+ func NewToSecondsFunction() *ToSecondsFunction

+ func (f *ToSecondsFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *ToSecondsFunction) Validate(args []interface{}) error

+ type TrimFunction struct

+ func NewTrimFunction() *TrimFunction

+ func (f *TrimFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *TrimFunction) Validate(args []interface{}) error

+ type TruncFunction struct

+ func NewTruncFunction() *TruncFunction

+ func (f *TruncFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *TruncFunction) Validate(args []interface{}) error

+ type UnixTimestampFunction struct

+ func NewUnixTimestampFunction() *UnixTimestampFunction

+ func (f *UnixTimestampFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *UnixTimestampFunction) Validate(args []interface{}) error

+ type UnnestFunction struct

+ func NewUnnestFunction() *UnnestFunction

+ func (f *UnnestFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *UnnestFunction) Validate(args []interface{}) error

+ type UnnestResult struct

+ Rows []map[string]interface{}

+ type UpperFunction struct

+ func NewUpperFunction() *UpperFunction

+ func (f *UpperFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *UpperFunction) Validate(args []interface{}) error

+ type UrlDecodeFunction struct

+ func NewUrlDecodeFunction() *UrlDecodeFunction

+ func (f *UrlDecodeFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *UrlDecodeFunction) Validate(args []interface{}) error

+ type UrlEncodeFunction struct

+ func NewUrlEncodeFunction() *UrlEncodeFunction

+ func (f *UrlEncodeFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *UrlEncodeFunction) Validate(args []interface{}) error

+ type VarAggregatorFunction struct

+ func NewVarAggregatorFunction() *VarAggregatorFunction

+ func (f *VarAggregatorFunction) Add(value interface{})

+ func (f *VarAggregatorFunction) Clone() AggregatorFunction

+ func (f *VarAggregatorFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *VarAggregatorFunction) New() AggregatorFunction

+ func (f *VarAggregatorFunction) Reset()

+ func (f *VarAggregatorFunction) Result() interface{}

+ func (f *VarAggregatorFunction) Validate(args []interface{}) error

+ type VarFunction struct

+ func NewVarFunction() *VarFunction

+ func (f *VarFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *VarFunction) Validate(args []interface{}) error

+ type VarSAggregatorFunction struct

+ func NewVarSAggregatorFunction() *VarSAggregatorFunction

+ func (f *VarSAggregatorFunction) Add(value interface{})

+ func (f *VarSAggregatorFunction) Clone() AggregatorFunction

+ func (f *VarSAggregatorFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *VarSAggregatorFunction) New() AggregatorFunction

+ func (f *VarSAggregatorFunction) Reset()

+ func (f *VarSAggregatorFunction) Result() interface{}

+ func (f *VarSAggregatorFunction) Validate(args []interface{}) error

+ type VarSFunction struct

+ func NewVarSFunction() *VarSFunction

+ func (f *VarSFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *VarSFunction) Validate(args []interface{}) error

+ type WeekOfYearFunction struct

+ func NewWeekOfYearFunction() *WeekOfYearFunction

+ func (f *WeekOfYearFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *WeekOfYearFunction) Validate(args []interface{}) error

+ type WindowEndFunction struct

+ func NewWindowEndFunction() *WindowEndFunction

+ func (f *WindowEndFunction) Add(value interface{})

+ func (f *WindowEndFunction) Clone() AggregatorFunction

+ func (f *WindowEndFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *WindowEndFunction) New() AggregatorFunction

+ func (f *WindowEndFunction) Reset()

+ func (f *WindowEndFunction) Result() interface{}

+ func (f *WindowEndFunction) Validate(args []interface{}) error

+ type WindowInfo struct

+ RowCount int

+ WindowEnd int64

+ WindowStart int64

+ type WindowStartFunction struct

+ func NewWindowStartFunction() *WindowStartFunction

+ func (f *WindowStartFunction) Add(value interface{})

+ func (f *WindowStartFunction) Clone() AggregatorFunction

+ func (f *WindowStartFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *WindowStartFunction) New() AggregatorFunction

+ func (f *WindowStartFunction) Reset()

+ func (f *WindowStartFunction) Result() interface{}

+ func (f *WindowStartFunction) Validate(args []interface{}) error

+ type YearFunction struct

+ func NewYearFunction() *YearFunction

+ func (f *YearFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error)

+ func (f *YearFunction) Validate(args []interface{}) error

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