mirror of
https://github.com/prometheus/prometheus.git
synced 2024-12-25 05:34:05 -08:00
Fix usages of ValueType
Signed-off-by: Tobias Guggenmos <tguggenm@redhat.com>
This commit is contained in:
Tobias Guggenmos
parent
65f5b9827d
commit
2f1113479f
|
|
@ -36,6 +36,7 @@ import (
|
|||
"github.com/prometheus/prometheus/pkg/labels"
|
||||
"github.com/prometheus/prometheus/pkg/timestamp"
|
||||
"github.com/prometheus/prometheus/pkg/value"
|
||||
"github.com/prometheus/prometheus/promql/parser"
|
||||
"github.com/prometheus/prometheus/storage"
|
||||
"github.com/prometheus/prometheus/util/stats"
|
||||
)
|
||||
|
|
@ -188,7 +189,7 @@ func (q *query) Exec(ctx context.Context) *Result {
|
|||
// Exec query.
|
||||
res, warnings, err := q.ng.exec(ctx, q)
|
||||
|
||||
return &Result{Err: err, Value: res, Warnings: warnings}
|
||||
return &Result{Err: err, parser.Value: res, Warnings: warnings}
|
||||
}
|
||||
|
||||
// contextDone returns an error if the context was canceled or timed out.
|
||||
|
|
@ -378,7 +379,7 @@ func (ng *Engine) NewRangeQuery(q storage.Queryable, qs string, start, end time.
|
|||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if expr.Type() != ValueTypeVector && expr.Type() != ValueTypeScalar {
|
||||
if expr.Type() != parser.ValueTypeVector && expr.Type() != parser.ValueTypeScalar {
|
||||
return nil, errors.Errorf("invalid expression type %q for range query, must be Scalar or instant Vector", documentedType(expr.Type()))
|
||||
}
|
||||
qry := ng.newQuery(q, expr, start, end, interval)
|
||||
|
|
@ -431,7 +432,7 @@ func (ng *Engine) newTestQuery(f func(context.Context) error) Query {
|
|||
//
|
||||
// At this point per query only one EvalStmt is evaluated. Alert and record
|
||||
// statements are not handled by the Engine.
|
||||
func (ng *Engine) exec(ctx context.Context, q *query) (v Value, w storage.Warnings, err error) {
|
||||
func (ng *Engine) exec(ctx context.Context, q *query) (v parser.Value, w storage.Warnings, err error) {
|
||||
ng.metrics.currentQueries.Inc()
|
||||
defer ng.metrics.currentQueries.Dec()
|
||||
|
||||
|
|
@ -454,7 +455,7 @@ func (ng *Engine) exec(ctx context.Context, q *query) (v Value, w storage.Warnin
|
|||
f = append(f, "error", err)
|
||||
}
|
||||
f = append(f, "stats", stats.NewQueryStats(q.Stats()))
|
||||
if origin := ctx.Value(queryOrigin); origin != nil {
|
||||
if origin := ctx.parser.Value(queryOrigin); origin != nil {
|
||||
for k, v := range origin.(map[string]interface{}) {
|
||||
f = append(f, k, v)
|
||||
}
|
||||
|
|
@ -515,7 +516,7 @@ func durationMilliseconds(d time.Duration) int64 {
|
|||
}
|
||||
|
||||
// execEvalStmt evaluates the expression of an evaluation statement for the given time range.
|
||||
func (ng *Engine) execEvalStmt(ctx context.Context, query *query, s *EvalStmt) (Value, storage.Warnings, error) {
|
||||
func (ng *Engine) execEvalStmt(ctx context.Context, query *query, s *EvalStmt) (parser.Value, storage.Warnings, error) {
|
||||
prepareSpanTimer, ctxPrepare := query.stats.GetSpanTimer(ctx, stats.QueryPreparationTime, ng.metrics.queryPrepareTime)
|
||||
querier, warnings, err := ng.populateSeries(ctxPrepare, query.queryable, s)
|
||||
prepareSpanTimer.Finish()
|
||||
|
|
@ -566,7 +567,7 @@ func (ng *Engine) execEvalStmt(ctx context.Context, query *query, s *EvalStmt) (
|
|||
|
||||
query.matrix = mat
|
||||
switch s.Expr.Type() {
|
||||
case ValueTypeVector:
|
||||
case parser.ValueTypeVector:
|
||||
// Convert matrix with one value per series into vector.
|
||||
vector := make(Vector, len(mat))
|
||||
for i, s := range mat {
|
||||
|
|
@ -575,9 +576,9 @@ func (ng *Engine) execEvalStmt(ctx context.Context, query *query, s *EvalStmt) (
|
|||
vector[i] = Sample{Metric: s.Metric, Point: Point{V: s.Points[0].V, T: start}}
|
||||
}
|
||||
return vector, warnings, nil
|
||||
case ValueTypeScalar:
|
||||
case parser.ValueTypeScalar:
|
||||
return Scalar{V: mat[0].Points[0].V, T: start}, warnings, nil
|
||||
case ValueTypeMatrix:
|
||||
case parser.ValueTypeMatrix:
|
||||
return mat, warnings, nil
|
||||
default:
|
||||
panic(errors.Errorf("promql.Engine.exec: unexpected expression type %q", s.Expr.Type()))
|
||||
|
|
@ -825,7 +826,7 @@ func (ev *evaluator) recover(errp *error) {
|
|||
}
|
||||
}
|
||||
|
||||
func (ev *evaluator) Eval(expr Expr) (v Value, err error) {
|
||||
func (ev *evaluator) Eval(expr Expr) (v parser.Value, err error) {
|
||||
defer ev.recover(&err)
|
||||
return ev.eval(expr), nil
|
||||
}
|
||||
|
|
@ -890,7 +891,7 @@ func (enh *EvalNodeHelper) signatureFunc(on bool, names ...string) func(labels.L
|
|||
// the given function with the values computed for each expression at that
|
||||
// step. The return value is the combination into time series of all the
|
||||
// function call results.
|
||||
func (ev *evaluator) rangeEval(f func([]Value, *EvalNodeHelper) Vector, exprs ...Expr) Matrix {
|
||||
func (ev *evaluator) rangeEval(f func([]parser.Value, *EvalNodeHelper) Vector, exprs ...Expr) Matrix {
|
||||
numSteps := int((ev.endTimestamp-ev.startTimestamp)/ev.interval) + 1
|
||||
matrixes := make([]Matrix, len(exprs))
|
||||
origMatrixes := make([]Matrix, len(exprs))
|
||||
|
|
@ -898,7 +899,7 @@ func (ev *evaluator) rangeEval(f func([]Value, *EvalNodeHelper) Vector, exprs ..
|
|||
|
||||
for i, e := range exprs {
|
||||
// Functions will take string arguments from the expressions, not the values.
|
||||
if e != nil && e.Type() != ValueTypeString {
|
||||
if e != nil && e.Type() != parser.ValueTypeString {
|
||||
// ev.currentSamples will be updated to the correct value within the ev.eval call.
|
||||
matrixes[i] = ev.eval(e).(Matrix)
|
||||
|
||||
|
|
@ -909,8 +910,8 @@ func (ev *evaluator) rangeEval(f func([]Value, *EvalNodeHelper) Vector, exprs ..
|
|||
}
|
||||
}
|
||||
|
||||
vectors := make([]Vector, len(exprs)) // Input vectors for the function.
|
||||
args := make([]Value, len(exprs)) // Argument to function.
|
||||
vectors := make([]Vector, len(exprs)) // Input vectors for the function.
|
||||
args := make([]parser.Value, len(exprs)) // Argument to function.
|
||||
// Create an output vector that is as big as the input matrix with
|
||||
// the most time series.
|
||||
biggestLen := 1
|
||||
|
|
@ -1029,7 +1030,7 @@ func (ev *evaluator) evalSubquery(subq *SubqueryExpr) *MatrixSelector {
|
|||
}
|
||||
|
||||
// eval evaluates the given expression as the given AST expression node requires.
|
||||
func (ev *evaluator) eval(expr Expr) Value {
|
||||
func (ev *evaluator) eval(expr Expr) parser.Value {
|
||||
// This is the top-level evaluation method.
|
||||
// Thus, we check for timeout/cancellation here.
|
||||
if err := contextDone(ev.ctx, "expression evaluation"); err != nil {
|
||||
|
|
@ -1041,11 +1042,11 @@ func (ev *evaluator) eval(expr Expr) Value {
|
|||
case *AggregateExpr:
|
||||
unwrapParenExpr(&e.Param)
|
||||
if s, ok := e.Param.(*StringLiteral); ok {
|
||||
return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
|
||||
return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
|
||||
return ev.aggregation(e.Op, e.Grouping, e.Without, s.Val, v[0].(Vector), enh)
|
||||
}, e.Expr)
|
||||
}
|
||||
return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
|
||||
return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
|
||||
var param float64
|
||||
if e.Param != nil {
|
||||
param = v[0].(Vector)[0].V
|
||||
|
|
@ -1060,8 +1061,8 @@ func (ev *evaluator) eval(expr Expr) Value {
|
|||
// a vector selector.
|
||||
vs, ok := e.Args[0].(*VectorSelector)
|
||||
if ok {
|
||||
return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
|
||||
return e.Func.Call([]Value{ev.vectorSelector(vs, enh.ts)}, e.Args, enh)
|
||||
return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
|
||||
return e.Func.Call([]parser.Value{ev.vectorSelector(vs, enh.ts)}, e.Args, enh)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
@ -1088,12 +1089,12 @@ func (ev *evaluator) eval(expr Expr) Value {
|
|||
}
|
||||
if !matrixArg {
|
||||
// Does not have a matrix argument.
|
||||
return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
|
||||
return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
|
||||
return e.Func.Call(v, e.Args, enh)
|
||||
}, e.Args...)
|
||||
}
|
||||
|
||||
inArgs := make([]Value, len(e.Args))
|
||||
inArgs := make([]parser.Value, len(e.Args))
|
||||
// Evaluate any non-matrix arguments.
|
||||
otherArgs := make([]Matrix, len(e.Args))
|
||||
otherInArgs := make([]Vector, len(e.Args))
|
||||
|
|
@ -1240,44 +1241,44 @@ func (ev *evaluator) eval(expr Expr) Value {
|
|||
|
||||
case *BinaryExpr:
|
||||
switch lt, rt := e.LHS.Type(), e.RHS.Type(); {
|
||||
case lt == ValueTypeScalar && rt == ValueTypeScalar:
|
||||
return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
|
||||
case lt == parser.ValueTypeScalar && rt == parser.ValueTypeScalar:
|
||||
return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
|
||||
val := scalarBinop(e.Op, v[0].(Vector)[0].Point.V, v[1].(Vector)[0].Point.V)
|
||||
return append(enh.out, Sample{Point: Point{V: val}})
|
||||
}, e.LHS, e.RHS)
|
||||
case lt == ValueTypeVector && rt == ValueTypeVector:
|
||||
case lt == parser.ValueTypeVector && rt == parser.ValueTypeVector:
|
||||
switch e.Op {
|
||||
case LAND:
|
||||
return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
|
||||
return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
|
||||
return ev.VectorAnd(v[0].(Vector), v[1].(Vector), e.VectorMatching, enh)
|
||||
}, e.LHS, e.RHS)
|
||||
case LOR:
|
||||
return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
|
||||
return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
|
||||
return ev.VectorOr(v[0].(Vector), v[1].(Vector), e.VectorMatching, enh)
|
||||
}, e.LHS, e.RHS)
|
||||
case LUNLESS:
|
||||
return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
|
||||
return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
|
||||
return ev.VectorUnless(v[0].(Vector), v[1].(Vector), e.VectorMatching, enh)
|
||||
}, e.LHS, e.RHS)
|
||||
default:
|
||||
return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
|
||||
return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
|
||||
return ev.VectorBinop(e.Op, v[0].(Vector), v[1].(Vector), e.VectorMatching, e.ReturnBool, enh)
|
||||
}, e.LHS, e.RHS)
|
||||
}
|
||||
|
||||
case lt == ValueTypeVector && rt == ValueTypeScalar:
|
||||
return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
|
||||
case lt == parser.ValueTypeVector && rt == parser.ValueTypeScalar:
|
||||
return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
|
||||
return ev.VectorscalarBinop(e.Op, v[0].(Vector), Scalar{V: v[1].(Vector)[0].Point.V}, false, e.ReturnBool, enh)
|
||||
}, e.LHS, e.RHS)
|
||||
|
||||
case lt == ValueTypeScalar && rt == ValueTypeVector:
|
||||
return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
|
||||
case lt == parser.ValueTypeScalar && rt == parser.ValueTypeVector:
|
||||
return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
|
||||
return ev.VectorscalarBinop(e.Op, v[1].(Vector), Scalar{V: v[0].(Vector)[0].Point.V}, true, e.ReturnBool, enh)
|
||||
}, e.LHS, e.RHS)
|
||||
}
|
||||
|
||||
case *NumberLiteral:
|
||||
return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
|
||||
return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
|
||||
return append(enh.out, Sample{Point: Point{V: e.Val}})
|
||||
})
|
||||
|
||||
|
|
@ -1400,7 +1401,7 @@ func (ev *evaluator) vectorSelectorSingle(it *storage.BufferedSeriesIterator, no
|
|||
}
|
||||
|
||||
if ok {
|
||||
t, v = it.Values()
|
||||
t, v = it.parser.Values()
|
||||
}
|
||||
|
||||
if !ok || t > refTime {
|
||||
|
|
@ -1505,7 +1506,7 @@ func (ev *evaluator) matrixIterSlice(it *storage.BufferedSeriesIterator, mint, m
|
|||
if value.IsStaleNaN(v) {
|
||||
continue
|
||||
}
|
||||
// Values in the buffer are guaranteed to be smaller than maxt.
|
||||
// parser.Values in the buffer are guaranteed to be smaller than maxt.
|
||||
if t >= mint {
|
||||
if ev.currentSamples >= ev.maxSamples {
|
||||
ev.error(ErrTooManySamples(env))
|
||||
|
|
@ -1516,7 +1517,7 @@ func (ev *evaluator) matrixIterSlice(it *storage.BufferedSeriesIterator, mint, m
|
|||
}
|
||||
// The seeked sample might also be in the range.
|
||||
if ok {
|
||||
t, v := it.Values()
|
||||
t, v := it.parser.Values()
|
||||
if t == maxt && !value.IsStaleNaN(v) {
|
||||
if ev.currentSamples >= ev.maxSamples {
|
||||
ev.error(ErrTooManySamples(env))
|
||||
|
|
|
|||
|
|
@ -26,6 +26,7 @@ import (
|
|||
"github.com/go-kit/kit/log"
|
||||
|
||||
"github.com/prometheus/prometheus/pkg/labels"
|
||||
"github.com/prometheus/prometheus/promql/parser"
|
||||
"github.com/prometheus/prometheus/storage"
|
||||
"github.com/prometheus/prometheus/util/testutil"
|
||||
)
|
||||
|
|
@ -522,7 +523,7 @@ load 10s
|
|||
|
||||
cases := []struct {
|
||||
Query string
|
||||
Result Value
|
||||
Result parser.Value
|
||||
Start time.Time
|
||||
End time.Time
|
||||
Interval time.Duration
|
||||
|
|
@ -604,7 +605,7 @@ load 10s
|
|||
}
|
||||
|
||||
testutil.Ok(t, res.Err)
|
||||
testutil.Equals(t, c.Result, res.Value)
|
||||
testutil.Equals(t, c.Result, res.parser.Value)
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -822,7 +823,7 @@ load 10s
|
|||
|
||||
res := qry.Exec(test.Context())
|
||||
testutil.Equals(t, c.Result.Err, res.Err)
|
||||
testutil.Equals(t, c.Result.Value, res.Value)
|
||||
testutil.Equals(t, c.Result.parser.Value, res.parser.Value)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1106,9 +1107,9 @@ func TestSubquerySelector(t *testing.T) {
|
|||
|
||||
res := qry.Exec(test.Context())
|
||||
testutil.Equals(t, c.Result.Err, res.Err)
|
||||
mat := res.Value.(Matrix)
|
||||
mat := res.parser.Value.(Matrix)
|
||||
sort.Sort(mat)
|
||||
testutil.Equals(t, c.Result.Value, mat)
|
||||
testutil.Equals(t, c.Result.parser.Value, mat)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -25,15 +25,16 @@ import (
|
|||
"github.com/prometheus/common/model"
|
||||
|
||||
"github.com/prometheus/prometheus/pkg/labels"
|
||||
"github.com/prometheus/prometheus/promql/parser"
|
||||
)
|
||||
|
||||
// Function represents a function of the expression language and is
|
||||
// used by function nodes.
|
||||
type Function struct {
|
||||
Name string
|
||||
ArgTypes []ValueType
|
||||
ArgTypes []parser.ValueType
|
||||
Variadic int
|
||||
ReturnType ValueType
|
||||
ReturnType parser.ValueType
|
||||
|
||||
// vals is a list of the evaluated arguments for the function call.
|
||||
// For range vectors it will be a Matrix with one series, instant vectors a
|
||||
|
|
@ -48,11 +49,11 @@ type Function struct {
|
|||
// Instant vector functions need only return a vector with the right values and
|
||||
// metrics, the timestamp are not needed.
|
||||
// Scalar results should be returned as the value of a sample in a Vector.
|
||||
Call func(vals []Value, args Expressions, enh *EvalNodeHelper) Vector
|
||||
Call func(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector
|
||||
}
|
||||
|
||||
// === time() float64 ===
|
||||
func funcTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
func funcTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return Vector{Sample{Point: Point{
|
||||
V: float64(enh.ts) / 1000,
|
||||
}}}
|
||||
|
|
@ -62,7 +63,7 @@ func funcTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
|||
// It calculates the rate (allowing for counter resets if isCounter is true),
|
||||
// extrapolates if the first/last sample is close to the boundary, and returns
|
||||
// the result as either per-second (if isRate is true) or overall.
|
||||
func extrapolatedRate(vals []Value, args Expressions, enh *EvalNodeHelper, isCounter bool, isRate bool) Vector {
|
||||
func extrapolatedRate(vals []parser.Value, args Expressions, enh *EvalNodeHelper, isCounter bool, isRate bool) Vector {
|
||||
ms := args[0].(*MatrixSelector)
|
||||
vs := ms.VectorSelector.(*VectorSelector)
|
||||
|
||||
|
|
@ -137,32 +138,32 @@ func extrapolatedRate(vals []Value, args Expressions, enh *EvalNodeHelper, isCou
|
|||
})
|
||||
}
|
||||
|
||||
// === delta(Matrix ValueTypeMatrix) Vector ===
|
||||
func funcDelta(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === delta(Matrix parser.ValueTypeMatrix) Vector ===
|
||||
func funcDelta(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return extrapolatedRate(vals, args, enh, false, false)
|
||||
}
|
||||
|
||||
// === rate(node ValueTypeMatrix) Vector ===
|
||||
func funcRate(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === rate(node parser.ValueTypeMatrix) Vector ===
|
||||
func funcRate(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return extrapolatedRate(vals, args, enh, true, true)
|
||||
}
|
||||
|
||||
// === increase(node ValueTypeMatrix) Vector ===
|
||||
func funcIncrease(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === increase(node parser.ValueTypeMatrix) Vector ===
|
||||
func funcIncrease(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return extrapolatedRate(vals, args, enh, true, false)
|
||||
}
|
||||
|
||||
// === irate(node ValueTypeMatrix) Vector ===
|
||||
func funcIrate(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === irate(node parser.ValueTypeMatrix) Vector ===
|
||||
func funcIrate(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return instantValue(vals, enh.out, true)
|
||||
}
|
||||
|
||||
// === idelta(node model.ValMatrix) Vector ===
|
||||
func funcIdelta(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
func funcIdelta(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return instantValue(vals, enh.out, false)
|
||||
}
|
||||
|
||||
func instantValue(vals []Value, out Vector, isRate bool) Vector {
|
||||
func instantValue(vals []parser.Value, out Vector, isRate bool) Vector {
|
||||
samples := vals[0].(Matrix)[0]
|
||||
// No sense in trying to compute a rate without at least two points. Drop
|
||||
// this Vector element.
|
||||
|
|
@ -218,7 +219,7 @@ func calcTrendValue(i int, sf, tf, s0, s1, b float64) float64 {
|
|||
// data. A lower smoothing factor increases the influence of historical data. The trend factor (0 < tf < 1) affects
|
||||
// how trends in historical data will affect the current data. A higher trend factor increases the influence.
|
||||
// of trends. Algorithm taken from https://en.wikipedia.org/wiki/Exponential_smoothing titled: "Double exponential smoothing".
|
||||
func funcHoltWinters(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
func funcHoltWinters(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
samples := vals[0].(Matrix)[0]
|
||||
|
||||
// The smoothing factor argument.
|
||||
|
|
@ -266,8 +267,8 @@ func funcHoltWinters(vals []Value, args Expressions, enh *EvalNodeHelper) Vector
|
|||
})
|
||||
}
|
||||
|
||||
// === sort(node ValueTypeVector) Vector ===
|
||||
func funcSort(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === sort(node parser.ValueTypeVector) Vector ===
|
||||
func funcSort(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// NaN should sort to the bottom, so take descending sort with NaN first and
|
||||
// reverse it.
|
||||
byValueSorter := vectorByReverseValueHeap(vals[0].(Vector))
|
||||
|
|
@ -275,8 +276,8 @@ func funcSort(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
|||
return Vector(byValueSorter)
|
||||
}
|
||||
|
||||
// === sortDesc(node ValueTypeVector) Vector ===
|
||||
func funcSortDesc(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === sortDesc(node parser.ValueTypeVector) Vector ===
|
||||
func funcSortDesc(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// NaN should sort to the bottom, so take ascending sort with NaN first and
|
||||
// reverse it.
|
||||
byValueSorter := vectorByValueHeap(vals[0].(Vector))
|
||||
|
|
@ -284,8 +285,8 @@ func funcSortDesc(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
|||
return Vector(byValueSorter)
|
||||
}
|
||||
|
||||
// === clamp_max(Vector ValueTypeVector, max Scalar) Vector ===
|
||||
func funcClampMax(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === clamp_max(Vector parser.ValueTypeVector, max Scalar) Vector ===
|
||||
func funcClampMax(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
vec := vals[0].(Vector)
|
||||
max := vals[1].(Vector)[0].Point.V
|
||||
for _, el := range vec {
|
||||
|
|
@ -297,8 +298,8 @@ func funcClampMax(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
|||
return enh.out
|
||||
}
|
||||
|
||||
// === clamp_min(Vector ValueTypeVector, min Scalar) Vector ===
|
||||
func funcClampMin(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === clamp_min(Vector parser.ValueTypeVector, min Scalar) Vector ===
|
||||
func funcClampMin(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
vec := vals[0].(Vector)
|
||||
min := vals[1].(Vector)[0].Point.V
|
||||
for _, el := range vec {
|
||||
|
|
@ -310,8 +311,8 @@ func funcClampMin(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
|||
return enh.out
|
||||
}
|
||||
|
||||
// === round(Vector ValueTypeVector, toNearest=1 Scalar) Vector ===
|
||||
func funcRound(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === round(Vector parser.ValueTypeVector, toNearest=1 Scalar) Vector ===
|
||||
func funcRound(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
vec := vals[0].(Vector)
|
||||
// round returns a number rounded to toNearest.
|
||||
// Ties are solved by rounding up.
|
||||
|
|
@ -332,8 +333,8 @@ func funcRound(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
|||
return enh.out
|
||||
}
|
||||
|
||||
// === Scalar(node ValueTypeVector) Scalar ===
|
||||
func funcScalar(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === Scalar(node parser.ValueTypeVector) Scalar ===
|
||||
func funcScalar(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
v := vals[0].(Vector)
|
||||
if len(v) != 1 {
|
||||
return append(enh.out, Sample{
|
||||
|
|
@ -345,7 +346,7 @@ func funcScalar(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
|||
})
|
||||
}
|
||||
|
||||
func aggrOverTime(vals []Value, enh *EvalNodeHelper, aggrFn func([]Point) float64) Vector {
|
||||
func aggrOverTime(vals []parser.Value, enh *EvalNodeHelper, aggrFn func([]Point) float64) Vector {
|
||||
el := vals[0].(Matrix)[0]
|
||||
|
||||
return append(enh.out, Sample{
|
||||
|
|
@ -353,8 +354,8 @@ func aggrOverTime(vals []Value, enh *EvalNodeHelper, aggrFn func([]Point) float6
|
|||
})
|
||||
}
|
||||
|
||||
// === avg_over_time(Matrix ValueTypeMatrix) Vector ===
|
||||
func funcAvgOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === avg_over_time(Matrix parser.ValueTypeMatrix) Vector ===
|
||||
func funcAvgOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return aggrOverTime(vals, enh, func(values []Point) float64 {
|
||||
var mean, count float64
|
||||
for _, v := range values {
|
||||
|
|
@ -365,16 +366,16 @@ func funcAvgOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector
|
|||
})
|
||||
}
|
||||
|
||||
// === count_over_time(Matrix ValueTypeMatrix) Vector ===
|
||||
func funcCountOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === count_over_time(Matrix parser.ValueTypeMatrix) Vector ===
|
||||
func funcCountOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return aggrOverTime(vals, enh, func(values []Point) float64 {
|
||||
return float64(len(values))
|
||||
})
|
||||
}
|
||||
|
||||
// === floor(Vector ValueTypeVector) Vector ===
|
||||
// === max_over_time(Matrix ValueTypeMatrix) Vector ===
|
||||
func funcMaxOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === floor(Vector parser.ValueTypeVector) Vector ===
|
||||
// === max_over_time(Matrix parser.ValueTypeMatrix) Vector ===
|
||||
func funcMaxOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return aggrOverTime(vals, enh, func(values []Point) float64 {
|
||||
max := values[0].V
|
||||
for _, v := range values {
|
||||
|
|
@ -386,8 +387,8 @@ func funcMaxOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector
|
|||
})
|
||||
}
|
||||
|
||||
// === min_over_time(Matrix ValueTypeMatrix) Vector ===
|
||||
func funcMinOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === min_over_time(Matrix parser.ValueTypeMatrix) Vector ===
|
||||
func funcMinOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return aggrOverTime(vals, enh, func(values []Point) float64 {
|
||||
min := values[0].V
|
||||
for _, v := range values {
|
||||
|
|
@ -399,8 +400,8 @@ func funcMinOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector
|
|||
})
|
||||
}
|
||||
|
||||
// === sum_over_time(Matrix ValueTypeMatrix) Vector ===
|
||||
func funcSumOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === sum_over_time(Matrix parser.ValueTypeMatrix) Vector ===
|
||||
func funcSumOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return aggrOverTime(vals, enh, func(values []Point) float64 {
|
||||
var sum float64
|
||||
for _, v := range values {
|
||||
|
|
@ -410,8 +411,8 @@ func funcSumOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector
|
|||
})
|
||||
}
|
||||
|
||||
// === quantile_over_time(Matrix ValueTypeMatrix) Vector ===
|
||||
func funcQuantileOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === quantile_over_time(Matrix parser.ValueTypeMatrix) Vector ===
|
||||
func funcQuantileOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
q := vals[0].(Vector)[0].V
|
||||
el := vals[1].(Matrix)[0]
|
||||
|
||||
|
|
@ -424,8 +425,8 @@ func funcQuantileOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) V
|
|||
})
|
||||
}
|
||||
|
||||
// === stddev_over_time(Matrix ValueTypeMatrix) Vector ===
|
||||
func funcStddevOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === stddev_over_time(Matrix parser.ValueTypeMatrix) Vector ===
|
||||
func funcStddevOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return aggrOverTime(vals, enh, func(values []Point) float64 {
|
||||
var aux, count, mean float64
|
||||
for _, v := range values {
|
||||
|
|
@ -438,8 +439,8 @@ func funcStddevOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vec
|
|||
})
|
||||
}
|
||||
|
||||
// === stdvar_over_time(Matrix ValueTypeMatrix) Vector ===
|
||||
func funcStdvarOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === stdvar_over_time(Matrix parser.ValueTypeMatrix) Vector ===
|
||||
func funcStdvarOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return aggrOverTime(vals, enh, func(values []Point) float64 {
|
||||
var aux, count, mean float64
|
||||
for _, v := range values {
|
||||
|
|
@ -452,8 +453,8 @@ func funcStdvarOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vec
|
|||
})
|
||||
}
|
||||
|
||||
// === absent(Vector ValueTypeVector) Vector ===
|
||||
func funcAbsent(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === absent(Vector parser.ValueTypeVector) Vector ===
|
||||
func funcAbsent(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
if len(vals[0].(Vector)) > 0 {
|
||||
return enh.out
|
||||
}
|
||||
|
|
@ -464,19 +465,19 @@ func funcAbsent(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
|||
})
|
||||
}
|
||||
|
||||
// === absent_over_time(Vector ValueTypeMatrix) Vector ===
|
||||
// === absent_over_time(Vector parser.ValueTypeMatrix) Vector ===
|
||||
// As this function has a matrix as argument, it does not get all the Series.
|
||||
// This function will return 1 if the matrix has at least one element.
|
||||
// Due to engine optimization, this function is only called when this condition is true.
|
||||
// Then, the engine post-processes the results to get the expected output.
|
||||
func funcAbsentOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
func funcAbsentOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return append(enh.out,
|
||||
Sample{
|
||||
Point: Point{V: 1},
|
||||
})
|
||||
}
|
||||
|
||||
func simpleFunc(vals []Value, enh *EvalNodeHelper, f func(float64) float64) Vector {
|
||||
func simpleFunc(vals []parser.Value, enh *EvalNodeHelper, f func(float64) float64) Vector {
|
||||
for _, el := range vals[0].(Vector) {
|
||||
enh.out = append(enh.out, Sample{
|
||||
Metric: enh.dropMetricName(el.Metric),
|
||||
|
|
@ -486,48 +487,48 @@ func simpleFunc(vals []Value, enh *EvalNodeHelper, f func(float64) float64) Vect
|
|||
return enh.out
|
||||
}
|
||||
|
||||
// === abs(Vector ValueTypeVector) Vector ===
|
||||
func funcAbs(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === abs(Vector parser.ValueTypeVector) Vector ===
|
||||
func funcAbs(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return simpleFunc(vals, enh, math.Abs)
|
||||
}
|
||||
|
||||
// === ceil(Vector ValueTypeVector) Vector ===
|
||||
func funcCeil(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === ceil(Vector parser.ValueTypeVector) Vector ===
|
||||
func funcCeil(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return simpleFunc(vals, enh, math.Ceil)
|
||||
}
|
||||
|
||||
// === floor(Vector ValueTypeVector) Vector ===
|
||||
func funcFloor(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === floor(Vector parser.ValueTypeVector) Vector ===
|
||||
func funcFloor(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return simpleFunc(vals, enh, math.Floor)
|
||||
}
|
||||
|
||||
// === exp(Vector ValueTypeVector) Vector ===
|
||||
func funcExp(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === exp(Vector parser.ValueTypeVector) Vector ===
|
||||
func funcExp(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return simpleFunc(vals, enh, math.Exp)
|
||||
}
|
||||
|
||||
// === sqrt(Vector VectorNode) Vector ===
|
||||
func funcSqrt(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
func funcSqrt(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return simpleFunc(vals, enh, math.Sqrt)
|
||||
}
|
||||
|
||||
// === ln(Vector ValueTypeVector) Vector ===
|
||||
func funcLn(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === ln(Vector parser.ValueTypeVector) Vector ===
|
||||
func funcLn(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return simpleFunc(vals, enh, math.Log)
|
||||
}
|
||||
|
||||
// === log2(Vector ValueTypeVector) Vector ===
|
||||
func funcLog2(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === log2(Vector parser.ValueTypeVector) Vector ===
|
||||
func funcLog2(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return simpleFunc(vals, enh, math.Log2)
|
||||
}
|
||||
|
||||
// === log10(Vector ValueTypeVector) Vector ===
|
||||
func funcLog10(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === log10(Vector parser.ValueTypeVector) Vector ===
|
||||
func funcLog10(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return simpleFunc(vals, enh, math.Log10)
|
||||
}
|
||||
|
||||
// === timestamp(Vector ValueTypeVector) Vector ===
|
||||
func funcTimestamp(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === timestamp(Vector parser.ValueTypeVector) Vector ===
|
||||
func funcTimestamp(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
vec := vals[0].(Vector)
|
||||
for _, el := range vec {
|
||||
enh.out = append(enh.out, Sample{
|
||||
|
|
@ -563,8 +564,8 @@ func linearRegression(samples []Point, interceptTime int64) (slope, intercept fl
|
|||
return slope, intercept
|
||||
}
|
||||
|
||||
// === deriv(node ValueTypeMatrix) Vector ===
|
||||
func funcDeriv(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === deriv(node parser.ValueTypeMatrix) Vector ===
|
||||
func funcDeriv(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
samples := vals[0].(Matrix)[0]
|
||||
|
||||
// No sense in trying to compute a derivative without at least two points.
|
||||
|
|
@ -582,8 +583,8 @@ func funcDeriv(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
|||
})
|
||||
}
|
||||
|
||||
// === predict_linear(node ValueTypeMatrix, k ValueTypeScalar) Vector ===
|
||||
func funcPredictLinear(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === predict_linear(node parser.ValueTypeMatrix, k parser.ValueTypeScalar) Vector ===
|
||||
func funcPredictLinear(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
samples := vals[0].(Matrix)[0]
|
||||
duration := vals[1].(Vector)[0].V
|
||||
|
||||
|
|
@ -599,8 +600,8 @@ func funcPredictLinear(vals []Value, args Expressions, enh *EvalNodeHelper) Vect
|
|||
})
|
||||
}
|
||||
|
||||
// === histogram_quantile(k ValueTypeScalar, Vector ValueTypeVector) Vector ===
|
||||
func funcHistogramQuantile(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === histogram_quantile(k parser.ValueTypeScalar, Vector parser.ValueTypeVector) Vector ===
|
||||
func funcHistogramQuantile(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
q := vals[0].(Vector)[0].V
|
||||
inVec := vals[1].(Vector)
|
||||
sigf := enh.signatureFunc(false, excludedLabels...)
|
||||
|
|
@ -647,8 +648,8 @@ func funcHistogramQuantile(vals []Value, args Expressions, enh *EvalNodeHelper)
|
|||
return enh.out
|
||||
}
|
||||
|
||||
// === resets(Matrix ValueTypeMatrix) Vector ===
|
||||
func funcResets(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === resets(Matrix parser.ValueTypeMatrix) Vector ===
|
||||
func funcResets(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
samples := vals[0].(Matrix)[0]
|
||||
|
||||
resets := 0
|
||||
|
|
@ -666,8 +667,8 @@ func funcResets(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
|||
})
|
||||
}
|
||||
|
||||
// === changes(Matrix ValueTypeMatrix) Vector ===
|
||||
func funcChanges(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === changes(Matrix parser.ValueTypeMatrix) Vector ===
|
||||
func funcChanges(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
samples := vals[0].(Matrix)[0]
|
||||
|
||||
changes := 0
|
||||
|
|
@ -685,8 +686,8 @@ func funcChanges(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
|||
})
|
||||
}
|
||||
|
||||
// === label_replace(Vector ValueTypeVector, dst_label, replacement, src_labelname, regex ValueTypeString) Vector ===
|
||||
func funcLabelReplace(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
// === label_replace(Vector parser.ValueTypeVector, dst_label, replacement, src_labelname, regex parser.ValueTypeString) Vector ===
|
||||
func funcLabelReplace(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
var (
|
||||
vector = vals[0].(Vector)
|
||||
dst = args[1].(*StringLiteral).Val
|
||||
|
|
@ -740,7 +741,7 @@ func funcLabelReplace(vals []Value, args Expressions, enh *EvalNodeHelper) Vecto
|
|||
}
|
||||
|
||||
// === Vector(s Scalar) Vector ===
|
||||
func funcVector(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
func funcVector(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return append(enh.out,
|
||||
Sample{
|
||||
Metric: labels.Labels{},
|
||||
|
|
@ -749,7 +750,7 @@ func funcVector(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
|||
}
|
||||
|
||||
// === label_join(vector model.ValVector, dest_labelname, separator, src_labelname...) Vector ===
|
||||
func funcLabelJoin(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
func funcLabelJoin(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
var (
|
||||
vector = vals[0].(Vector)
|
||||
dst = args[1].(*StringLiteral).Val
|
||||
|
|
@ -807,7 +808,7 @@ func funcLabelJoin(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
|||
}
|
||||
|
||||
// Common code for date related functions.
|
||||
func dateWrapper(vals []Value, enh *EvalNodeHelper, f func(time.Time) float64) Vector {
|
||||
func dateWrapper(vals []parser.Value, enh *EvalNodeHelper, f func(time.Time) float64) Vector {
|
||||
if len(vals) == 0 {
|
||||
return append(enh.out,
|
||||
Sample{
|
||||
|
|
@ -827,49 +828,49 @@ func dateWrapper(vals []Value, enh *EvalNodeHelper, f func(time.Time) float64) V
|
|||
}
|
||||
|
||||
// === days_in_month(v Vector) Scalar ===
|
||||
func funcDaysInMonth(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
func funcDaysInMonth(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return dateWrapper(vals, enh, func(t time.Time) float64 {
|
||||
return float64(32 - time.Date(t.Year(), t.Month(), 32, 0, 0, 0, 0, time.UTC).Day())
|
||||
})
|
||||
}
|
||||
|
||||
// === day_of_month(v Vector) Scalar ===
|
||||
func funcDayOfMonth(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
func funcDayOfMonth(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return dateWrapper(vals, enh, func(t time.Time) float64 {
|
||||
return float64(t.Day())
|
||||
})
|
||||
}
|
||||
|
||||
// === day_of_week(v Vector) Scalar ===
|
||||
func funcDayOfWeek(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
func funcDayOfWeek(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return dateWrapper(vals, enh, func(t time.Time) float64 {
|
||||
return float64(t.Weekday())
|
||||
})
|
||||
}
|
||||
|
||||
// === hour(v Vector) Scalar ===
|
||||
func funcHour(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
func funcHour(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return dateWrapper(vals, enh, func(t time.Time) float64 {
|
||||
return float64(t.Hour())
|
||||
})
|
||||
}
|
||||
|
||||
// === minute(v Vector) Scalar ===
|
||||
func funcMinute(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
func funcMinute(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return dateWrapper(vals, enh, func(t time.Time) float64 {
|
||||
return float64(t.Minute())
|
||||
})
|
||||
}
|
||||
|
||||
// === month(v Vector) Scalar ===
|
||||
func funcMonth(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
func funcMonth(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return dateWrapper(vals, enh, func(t time.Time) float64 {
|
||||
return float64(t.Month())
|
||||
})
|
||||
}
|
||||
|
||||
// === year(v Vector) Scalar ===
|
||||
func funcYear(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
func funcYear(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
|
||||
return dateWrapper(vals, enh, func(t time.Time) float64 {
|
||||
return float64(t.Year())
|
||||
})
|
||||
|
|
@ -879,293 +880,293 @@ func funcYear(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
|
|||
var Functions = map[string]*Function{
|
||||
"abs": {
|
||||
Name: "abs",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcAbs,
|
||||
},
|
||||
"absent": {
|
||||
Name: "absent",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcAbsent,
|
||||
},
|
||||
"absent_over_time": {
|
||||
Name: "absent_over_time",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcAbsentOverTime,
|
||||
},
|
||||
"avg_over_time": {
|
||||
Name: "avg_over_time",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcAvgOverTime,
|
||||
},
|
||||
"ceil": {
|
||||
Name: "ceil",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcCeil,
|
||||
},
|
||||
"changes": {
|
||||
Name: "changes",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcChanges,
|
||||
},
|
||||
"clamp_max": {
|
||||
Name: "clamp_max",
|
||||
ArgTypes: []ValueType{ValueTypeVector, ValueTypeScalar},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector, parser.ValueTypeScalar},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcClampMax,
|
||||
},
|
||||
"clamp_min": {
|
||||
Name: "clamp_min",
|
||||
ArgTypes: []ValueType{ValueTypeVector, ValueTypeScalar},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector, parser.ValueTypeScalar},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcClampMin,
|
||||
},
|
||||
"count_over_time": {
|
||||
Name: "count_over_time",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcCountOverTime,
|
||||
},
|
||||
"days_in_month": {
|
||||
Name: "days_in_month",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
Variadic: 1,
|
||||
ReturnType: ValueTypeVector,
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcDaysInMonth,
|
||||
},
|
||||
"day_of_month": {
|
||||
Name: "day_of_month",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
Variadic: 1,
|
||||
ReturnType: ValueTypeVector,
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcDayOfMonth,
|
||||
},
|
||||
"day_of_week": {
|
||||
Name: "day_of_week",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
Variadic: 1,
|
||||
ReturnType: ValueTypeVector,
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcDayOfWeek,
|
||||
},
|
||||
"delta": {
|
||||
Name: "delta",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcDelta,
|
||||
},
|
||||
"deriv": {
|
||||
Name: "deriv",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcDeriv,
|
||||
},
|
||||
"exp": {
|
||||
Name: "exp",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcExp,
|
||||
},
|
||||
"floor": {
|
||||
Name: "floor",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcFloor,
|
||||
},
|
||||
"histogram_quantile": {
|
||||
Name: "histogram_quantile",
|
||||
ArgTypes: []ValueType{ValueTypeScalar, ValueTypeVector},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeScalar, parser.ValueTypeVector},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcHistogramQuantile,
|
||||
},
|
||||
"holt_winters": {
|
||||
Name: "holt_winters",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix, ValueTypeScalar, ValueTypeScalar},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix, parser.ValueTypeScalar, parser.ValueTypeScalar},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcHoltWinters,
|
||||
},
|
||||
"hour": {
|
||||
Name: "hour",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
Variadic: 1,
|
||||
ReturnType: ValueTypeVector,
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcHour,
|
||||
},
|
||||
"idelta": {
|
||||
Name: "idelta",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcIdelta,
|
||||
},
|
||||
"increase": {
|
||||
Name: "increase",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcIncrease,
|
||||
},
|
||||
"irate": {
|
||||
Name: "irate",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcIrate,
|
||||
},
|
||||
"label_replace": {
|
||||
Name: "label_replace",
|
||||
ArgTypes: []ValueType{ValueTypeVector, ValueTypeString, ValueTypeString, ValueTypeString, ValueTypeString},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector, parser.ValueTypeString, parser.ValueTypeString, parser.ValueTypeString, parser.ValueTypeString},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcLabelReplace,
|
||||
},
|
||||
"label_join": {
|
||||
Name: "label_join",
|
||||
ArgTypes: []ValueType{ValueTypeVector, ValueTypeString, ValueTypeString, ValueTypeString},
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector, parser.ValueTypeString, parser.ValueTypeString, parser.ValueTypeString},
|
||||
Variadic: -1,
|
||||
ReturnType: ValueTypeVector,
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcLabelJoin,
|
||||
},
|
||||
"ln": {
|
||||
Name: "ln",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcLn,
|
||||
},
|
||||
"log10": {
|
||||
Name: "log10",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcLog10,
|
||||
},
|
||||
"log2": {
|
||||
Name: "log2",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcLog2,
|
||||
},
|
||||
"max_over_time": {
|
||||
Name: "max_over_time",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcMaxOverTime,
|
||||
},
|
||||
"min_over_time": {
|
||||
Name: "min_over_time",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcMinOverTime,
|
||||
},
|
||||
"minute": {
|
||||
Name: "minute",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
Variadic: 1,
|
||||
ReturnType: ValueTypeVector,
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcMinute,
|
||||
},
|
||||
"month": {
|
||||
Name: "month",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
Variadic: 1,
|
||||
ReturnType: ValueTypeVector,
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcMonth,
|
||||
},
|
||||
"predict_linear": {
|
||||
Name: "predict_linear",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix, ValueTypeScalar},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix, parser.ValueTypeScalar},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcPredictLinear,
|
||||
},
|
||||
"quantile_over_time": {
|
||||
Name: "quantile_over_time",
|
||||
ArgTypes: []ValueType{ValueTypeScalar, ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeScalar, parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcQuantileOverTime,
|
||||
},
|
||||
"rate": {
|
||||
Name: "rate",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcRate,
|
||||
},
|
||||
"resets": {
|
||||
Name: "resets",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcResets,
|
||||
},
|
||||
"round": {
|
||||
Name: "round",
|
||||
ArgTypes: []ValueType{ValueTypeVector, ValueTypeScalar},
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector, parser.ValueTypeScalar},
|
||||
Variadic: 1,
|
||||
ReturnType: ValueTypeVector,
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcRound,
|
||||
},
|
||||
"scalar": {
|
||||
Name: "scalar",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ReturnType: ValueTypeScalar,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
ReturnType: parser.ValueTypeScalar,
|
||||
Call: funcScalar,
|
||||
},
|
||||
"sort": {
|
||||
Name: "sort",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcSort,
|
||||
},
|
||||
"sort_desc": {
|
||||
Name: "sort_desc",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcSortDesc,
|
||||
},
|
||||
"sqrt": {
|
||||
Name: "sqrt",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcSqrt,
|
||||
},
|
||||
"stddev_over_time": {
|
||||
Name: "stddev_over_time",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcStddevOverTime,
|
||||
},
|
||||
"stdvar_over_time": {
|
||||
Name: "stdvar_over_time",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcStdvarOverTime,
|
||||
},
|
||||
"sum_over_time": {
|
||||
Name: "sum_over_time",
|
||||
ArgTypes: []ValueType{ValueTypeMatrix},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeMatrix},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcSumOverTime,
|
||||
},
|
||||
"time": {
|
||||
Name: "time",
|
||||
ArgTypes: []ValueType{},
|
||||
ReturnType: ValueTypeScalar,
|
||||
ArgTypes: []parser.ValueType{},
|
||||
ReturnType: parser.ValueTypeScalar,
|
||||
Call: funcTime,
|
||||
},
|
||||
"timestamp": {
|
||||
Name: "timestamp",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcTimestamp,
|
||||
},
|
||||
"vector": {
|
||||
Name: "vector",
|
||||
ArgTypes: []ValueType{ValueTypeScalar},
|
||||
ReturnType: ValueTypeVector,
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeScalar},
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcVector,
|
||||
},
|
||||
"year": {
|
||||
Name: "year",
|
||||
ArgTypes: []ValueType{ValueTypeVector},
|
||||
ArgTypes: []parser.ValueType{parser.ValueTypeVector},
|
||||
Variadic: 1,
|
||||
ReturnType: ValueTypeVector,
|
||||
ReturnType: parser.ValueTypeVector,
|
||||
Call: funcYear,
|
||||
},
|
||||
}
|
||||
|
|
@ -1255,7 +1256,7 @@ func createLabelsForAbsentFunction(expr Expr) labels.Labels {
|
|||
continue
|
||||
}
|
||||
if ma.Type == labels.MatchEqual && !m.Has(ma.Name) {
|
||||
m = labels.NewBuilder(m).Set(ma.Name, ma.Value).Labels()
|
||||
m = labels.NewBuilder(m).Set(ma.Name, ma.parser.Value).Labels()
|
||||
} else {
|
||||
empty = append(empty, ma.Name)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -27,6 +27,7 @@ import (
|
|||
"github.com/prometheus/common/model"
|
||||
|
||||
"github.com/prometheus/prometheus/pkg/labels"
|
||||
"github.com/prometheus/prometheus/promql/parser"
|
||||
"github.com/prometheus/prometheus/storage"
|
||||
"github.com/prometheus/prometheus/util/teststorage"
|
||||
"github.com/prometheus/prometheus/util/testutil"
|
||||
|
|
@ -357,7 +358,7 @@ func (ev *evalCmd) expect(pos int, m labels.Labels, vals ...sequenceValue) {
|
|||
}
|
||||
|
||||
// compareResult compares the result value with the defined expectation.
|
||||
func (ev *evalCmd) compareResult(result Value) error {
|
||||
func (ev *evalCmd) compareResult(result parser.Value) error {
|
||||
switch val := result.(type) {
|
||||
case Matrix:
|
||||
return errors.New("received range result on instant evaluation")
|
||||
|
|
@ -458,7 +459,7 @@ func (t *Test) exec(tc testCommand) error {
|
|||
return errors.Errorf("expected error evaluating query %q (line %d) but got none", cmd.expr, cmd.line)
|
||||
}
|
||||
|
||||
err = cmd.compareResult(res.Value)
|
||||
err = cmd.compareResult(res.parser.Value)
|
||||
if err != nil {
|
||||
return errors.Wrapf(err, "error in %s %s", cmd, cmd.expr)
|
||||
}
|
||||
|
|
@ -478,7 +479,7 @@ func (t *Test) exec(tc testCommand) error {
|
|||
// Ordering isn't defined for range queries.
|
||||
return nil
|
||||
}
|
||||
mat := rangeRes.Value.(Matrix)
|
||||
mat := rangeRes.parser.Value.(Matrix)
|
||||
vec := make(Vector, 0, len(mat))
|
||||
for _, series := range mat {
|
||||
for _, point := range series.Points {
|
||||
|
|
@ -488,7 +489,7 @@ func (t *Test) exec(tc testCommand) error {
|
|||
}
|
||||
}
|
||||
}
|
||||
if _, ok := res.Value.(Scalar); ok {
|
||||
if _, ok := res.parser.Value.(Scalar); ok {
|
||||
err = cmd.compareResult(Scalar{V: vec[0].Point.V})
|
||||
} else {
|
||||
err = cmd.compareResult(vec)
|
||||
|
|
|
|||
|
|
@ -127,7 +127,7 @@ func TestLazyLoader_WithSamplesTill(t *testing.T) {
|
|||
for _, s := range tc.series {
|
||||
var matchers []*labels.Matcher
|
||||
for _, label := range s.Metric {
|
||||
m, err := labels.NewMatcher(labels.MatchEqual, label.Name, label.Value)
|
||||
m, err := labels.NewMatcher(labels.MatchEqual, label.Name, label.parser.Value)
|
||||
testutil.Ok(t, err)
|
||||
matchers = append(matchers, m)
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue