transformations

Documentation

Index

• Variables
• func ApplyFilter(frame *data.Frame, filterExpression string) (*data.Frame, error)
• func FieldExists(frame *data.Frame, field *data.Field) bool
• func FilterExpression(input []*data.Frame, options FilterExpressionOptions) ([]*data.Frame, error)
• func GetFrameWithComputedColumns(frame *data.Frame, columns []ComputedColumn) (*data.Frame, error)
• func GetSummarizeByFrame(frame *data.Frame, expression, by string, alias string) (*data.Frame, error)
• func GetSummaryFrame(frame *data.Frame, expression string, by string, alias string) (*data.Frame, error)
• func Limit(input []*data.Frame, options LimitOptions) ([]*data.Frame, error)
• func Merge(inputFrames []*data.Frame, option MergeFramesOptions) (*data.Frame, error)
• type ComputedColumn
• type FilterExpressionOptions
• type LimitOptions
• type MergeFramesOptions

Variables

var ExpressionFunctions = map[string]govaluate.ExpressionFunction{
	"trim": func(arguments ...any) (any, error) {
		if len(arguments) < 1 {
			return nil, errors.New("invalid arguments to trim method")
		}
		if arg, ok := arguments[0].(*string); ok {
			return strings.TrimSpace(*arg), nil
		}
		if arg, ok := arguments[0].(string); ok {
			return strings.TrimSpace(arg), nil
		}
		return "", nil
	},
	"tolower": func(arguments ...any) (any, error) {
		if len(arguments) < 1 {
			return nil, errors.New("invalid arguments to tolower method")
		}
		if arg, ok := arguments[0].(*string); ok {
			return strings.ToLower(*arg), nil
		}
		if arg, ok := arguments[0].(string); ok {
			return strings.ToLower(arg), nil
		}
		return "", nil
	},
	"toupper": func(arguments ...any) (any, error) {
		if len(arguments) < 1 {
			return nil, errors.New("invalid arguments to toupper method")
		}
		if arg, ok := arguments[0].(*string); ok {
			return strings.ToUpper(*arg), nil
		}
		if arg, ok := arguments[0].(string); ok {
			return strings.ToUpper(arg), nil
		}
		return "", nil
	},
	"startswith": func(arguments ...any) (any, error) {
		if len(arguments) < 2 {
			return nil, errors.New("invalid arguments to startswith method")
		}
		var first *string
		var second *string
		if arg, ok := arguments[0].(*string); ok {
			first = arg
		}
		if arg, ok := arguments[0].(string); ok {
			first = &arg
		}
		if arg, ok := arguments[1].(*string); ok {
			second = arg
		}
		if arg, ok := arguments[1].(string); ok {
			second = &arg
		}
		if first != nil && second != nil {
			return strings.HasPrefix(*first, *second), nil
		}
		return false, nil
	},
	"endswith": func(arguments ...any) (any, error) {
		if len(arguments) < 2 {
			return nil, errors.New("invalid arguments to endswith method")
		}
		var first *string
		var second *string
		if arg, ok := arguments[0].(*string); ok {
			first = arg
		}
		if arg, ok := arguments[0].(string); ok {
			first = &arg
		}
		if arg, ok := arguments[1].(*string); ok {
			second = arg
		}
		if arg, ok := arguments[1].(string); ok {
			second = &arg
		}
		if first != nil && second != nil {
			return strings.HasSuffix(*first, *second), nil
		}
		return false, nil
	},
	"contains": func(arguments ...any) (any, error) {
		if len(arguments) < 2 {
			return nil, errors.New("invalid arguments to endswith method")
		}
		var first *string
		var second *string
		if arg, ok := arguments[0].(*string); ok {
			first = arg
		}
		if arg, ok := arguments[0].(string); ok {
			first = &arg
		}
		if arg, ok := arguments[1].(*string); ok {
			second = arg
		}
		if arg, ok := arguments[1].(string); ok {
			second = &arg
		}
		if first != nil && second != nil {
			return strings.Contains(*first, *second), nil
		}
		return false, nil
	},
	"replace": func(arguments ...any) (any, error) {
		if len(arguments) < 3 {
			return nil, errors.New("invalid arguments to endswith method")
		}
		var first *string
		var second *string
		var third *string
		if arg, ok := arguments[0].(*string); ok {
			first = arg
		}
		if arg, ok := arguments[0].(string); ok {
			first = &arg
		}
		if arg, ok := arguments[1].(*string); ok {
			second = arg
		}
		if arg, ok := arguments[1].(string); ok {
			second = &arg
		}
		if arg, ok := arguments[2].(*string); ok {
			third = arg
		}
		if arg, ok := arguments[2].(string); ok {
			third = &arg
		}

		if first != nil && second != nil && third != nil {
			return strings.ReplaceAll(*first, *second, *third), nil
		}
		return "", nil
	},
	"replace_all": func(arguments ...any) (any, error) {
		if len(arguments) < 3 {
			return nil, errors.New("invalid arguments to endswith method")
		}
		var first *string
		var second *string
		var third *string
		if arg, ok := arguments[0].(*string); ok {
			first = arg
		}
		if arg, ok := arguments[0].(string); ok {
			first = &arg
		}
		if arg, ok := arguments[1].(*string); ok {
			second = arg
		}
		if arg, ok := arguments[1].(string); ok {
			second = &arg
		}
		if arg, ok := arguments[2].(*string); ok {
			third = arg
		}
		if arg, ok := arguments[2].(string); ok {
			third = &arg
		}
		if first != nil && second != nil && third != nil {
			return strings.ReplaceAll(*first, *second, *third), nil
		}
		return "", nil
	},
	"guid": func(arguments ...any) (any, error) {
		id := uuid.New()
		return id.String(), nil
	},
	"uuid": func(arguments ...any) (any, error) {
		id := uuid.New()
		return id.String(), nil
	},
}

Functions

func ApplyFilter

func ApplyFilter(frame *data.Frame, filterExpression string) (*data.Frame, error)

func FieldExists

func FieldExists(frame *data.Frame, field *data.Field) bool

FieldExists checks if a field exist in a frame only field type and field name for uniqueness

func FilterExpression

func FilterExpression(input []*data.Frame, options FilterExpressionOptions) ([]*data.Frame, error)

func GetFrameWithComputedColumns

func GetFrameWithComputedColumns(frame *data.Frame, columns []ComputedColumn) (*data.Frame, error)

func GetSummarizeByFrame

func GetSummarizeByFrame(frame *data.Frame, expression, by string, alias string) (*data.Frame, error)

func GetSummaryFrame

func GetSummaryFrame(frame *data.Frame, expression string, by string, alias string) (*data.Frame, error)

func Limit

func Limit(input []*data.Frame, options LimitOptions) ([]*data.Frame, error)

func Merge

func Merge(inputFrames []*data.Frame, option MergeFramesOptions) (*data.Frame, error)

Merge transformation used to merge multiple dataframe of same structure into single frame Requirement: Fields length should be same across the frame Requirement: Field names for all the input frames must be same Requirement: Fields must not have labels. Any labels for the fields will be ignored Requirement: Field must be in same order. (??) Ref: https://github.com/grafana/grafana/blob/v9.5.2/packages/grafana-data/src/transformations/transformers/merge.ts

Types

type ComputedColumn

type ComputedColumn struct {
	Selector string `json:"selector"`
	Text     string `json:"text"`
}

type FilterExpressionOptions

type FilterExpressionOptions struct {
	Expression string `json:"expression,omitempty"`
}

type LimitOptions

type LimitOptions struct {
	LimitField int `json:"limitField,omitempty"`
}

type MergeFramesOptions

type MergeFramesOptions struct {
}