解析Prometheus PromQL

	// Aggregators.
	"sum":          SUM,
	"avg":          AVG,
	"count":        COUNT,
	"min":          MIN,
	"max":          MAX,
	"group":        GROUP,
	"stddev":       STDDEV,
	"stdvar":       STDVAR,
	"topk":         TOPK,
	"bottomk":      BOTTOMK,
	"count_values": COUNT_VALUES,
	"quantile":     QUANTILE,

type AggregateExpr struct {
	Op       ItemType // The used aggregation operation.
	Expr     Expr     // The Vector expression over which is aggregated.
	Param    Expr     // Parameter used by some aggregators.
	Grouping []string // The labels by which to group the Vector.
	Without  bool     // Whether to drop the given labels rather than keep them.
	PosRange PositionRange
}

// Functions is a list of all functions supported by PromQL, including their types.
var Functions = map[string]*Function{
	"abs": {
		Name:       "abs",
		ArgTypes:   []ValueType{ValueTypeVector},
		ReturnType: ValueTypeVector,
	},
	"absent": {
		Name:       "absent",
		ArgTypes:   []ValueType{ValueTypeVector},
		ReturnType: ValueTypeVector,
	},
	"absent_over_time": {
		Name:       "absent_over_time",
		ArgTypes:   []ValueType{ValueTypeMatrix},
		ReturnType: ValueTypeVector,
	},
	"avg_over_time": {
		Name:       "avg_over_time",
		ArgTypes:   []ValueType{ValueTypeMatrix},
		ReturnType: ValueTypeVector,
	},

type Call struct {
	Func *Function   // The function that was called.
	Args Expressions // Arguments used in the call.

	PosRange PositionRange
}

type ParenExpr struct {
	Expr     Expr
	PosRange PositionRange
}

type UnaryExpr struct {
	Op   ItemType
	Expr Expr

	StartPos Pos
}

type BinaryExpr struct {
   Op       ItemType // The operation of the expression.
   LHS, RHS Expr     // The operands on the respective sides of the operator.

   // The matching behavior for the operation if both operands are Vectors.
   // If they are not this field is nil.
   VectorMatching *VectorMatching

   // If a comparison operator, return 0/1 rather than filtering.
   ReturnBool bool
}

type NumberLiteral struct {
   Val float64

   PosRange PositionRange
}

type StringLiteral struct {
   Val      string
   PosRange PositionRange
}

type VectorSelector struct {
   Name          string
   Offset        time.Duration
   LabelMatchers []*labels.Matcher

   // The unexpanded seriesSet populated at query preparation time.
   UnexpandedSeriesSet storage.SeriesSet
   Series              []storage.Series

   PosRange PositionRange
}

type MatrixSelector struct {
   Name          string
   Range         time.Duration
   Offset        time.Duration
   LabelMatchers []*labels.Matcher

   // The series are populated at query preparation time.
   series []storage.Series
}

type SubqueryExpr struct {
	Expr   Expr
	Range  time.Duration
	Offset time.Duration
	Step   time.Duration

	EndPos Pos
}

import (
	"fmt"
	"github.com/pkg/errors"
	"github.com/prometheus/prometheus/promql/parser"
	"github.com/prometheus/prometheus/pkg/labels"
)

func injectLabels(expr parser.Expr, match labels.MatchType, name,value string){
	switch e := expr.(type) {
	case *parser.AggregateExpr:
		injectLabels(e.Expr,match,name,value)
	case *parser.Call:
		for _,v := range e.Args{
			injectLabels(v,match,name,value)
		}
	case *parser.ParenExpr:
		injectLabels(e.Expr,match,name,value)
	case *parser.UnaryExpr:
		injectLabels(e.Expr,match,name,value)
	case *parser.BinaryExpr:
		injectLabels(e.LHS,match,name,value)
		injectLabels(e.RHS,match,name,value)
	case *parser.VectorSelector:
		l := genMetricLabel(match,name,value)
		e.LabelMatchers = append(e.LabelMatchers, l)
		return
	case *parser.MatrixSelector:
		injectLabels(e.VectorSelector,match,name,value)
	case *parser.SubqueryExpr:
		injectLabels(e.Expr,match,name,value)
	case *parser.NumberLiteral,*parser.StringLiteral:
		return
	default:
		panic(errors.Errorf("unhandled expression of type: %T", expr))
	}
	return
}

func genMetricLabel(match labels.MatchType, name,value string) *labels.Matcher{
	m,err := labels.NewMatcher(match,name,value)
	if nil != err {
		return nil
	}

	return m
}

func main() {
	ql := `rate(http_requests_total[5m])[30m:1m]`
	expr,_ := parser.ParseExpr(ql)
	injectLabels(expr,labels.MatchNotRegexp,"appName","testAppName")
	fmt.Println(expr.String())
}

MatchEqual:     "=",
MatchNotEqual:  "!=",
MatchRegexp:    "=~",
MatchNotRegexp: "!~",