mirror of
https://github.com/prometheus/prometheus.git
synced 2025-01-24 04:02:04 -08:00
Fix all build errors in promql package
Signed-off-by: Tobias Guggenmos <tguggenm@redhat.com>
This commit is contained in:
Tobias Guggenmos
parent
2164e366ea
commit
1360f9ff12
144
promql/engine.go
144
promql/engine.go
|
|
@ -1265,19 +1265,19 @@ func (ev *evaluator) eval(expr parser.Expr) parser.Value {
|
|||
}, e.LHS, e.RHS)
|
||||
}
|
||||
|
||||
case *NumberLiteral:
|
||||
case *parser.NumberLiteral:
|
||||
return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
|
||||
return append(enh.out, Sample{Point: Point{V: e.Val}})
|
||||
})
|
||||
|
||||
case *parser.VectorSelector:
|
||||
checkForSeriesSetExpansion(ev.ctx, e)
|
||||
mat := make(Matrix, 0, len(e.series))
|
||||
mat := make(Matrix, 0, len(e.Series))
|
||||
it := storage.NewBuffer(durationMilliseconds(ev.lookbackDelta))
|
||||
for i, s := range e.series {
|
||||
for i, s := range e.Series {
|
||||
it.Reset(s.Iterator())
|
||||
ss := Series{
|
||||
Metric: e.series[i].Labels(),
|
||||
Metric: e.Series[i].Labels(),
|
||||
Points: getPointSlice(numSteps),
|
||||
}
|
||||
|
||||
|
|
@ -1336,7 +1336,7 @@ func (ev *evaluator) eval(expr parser.Expr) parser.Value {
|
|||
res := newEv.eval(e.Expr)
|
||||
ev.currentSamples = newEv.currentSamples
|
||||
return res
|
||||
case *StringLiteral:
|
||||
case *parser.StringLiteral:
|
||||
return String{V: e.Val, T: ev.startTimestamp}
|
||||
}
|
||||
|
||||
|
|
@ -1352,17 +1352,17 @@ func (ev *evaluator) vectorSelector(node *parser.VectorSelector, ts int64) Vecto
|
|||
checkForSeriesSetExpansion(ev.ctx, node)
|
||||
|
||||
var (
|
||||
vec = make(Vector, 0, len(node.series))
|
||||
vec = make(Vector, 0, len(node.Series))
|
||||
)
|
||||
|
||||
it := storage.NewBuffer(durationMilliseconds(ev.lookbackDelta))
|
||||
for i, s := range node.series {
|
||||
for i, s := range node.Series {
|
||||
it.Reset(s.Iterator())
|
||||
|
||||
t, v, ok := ev.vectorSelectorSingle(it, node, ts)
|
||||
if ok {
|
||||
vec = append(vec, Sample{
|
||||
Metric: node.series[i].Labels(),
|
||||
Metric: node.Series[i].Labels(),
|
||||
Point: Point{V: v, T: t},
|
||||
})
|
||||
ev.currentSamples++
|
||||
|
|
@ -1389,7 +1389,7 @@ func (ev *evaluator) vectorSelectorSingle(it *storage.BufferedSeriesIterator, no
|
|||
}
|
||||
|
||||
if ok {
|
||||
t, v = it.parser.Values()
|
||||
t, v = it.Values()
|
||||
}
|
||||
|
||||
if !ok || t > refTime {
|
||||
|
|
@ -1429,11 +1429,11 @@ func (ev *evaluator) matrixSelector(node *parser.MatrixSelector) Matrix {
|
|||
offset = durationMilliseconds(vs.Offset)
|
||||
maxt = ev.startTimestamp - offset
|
||||
mint = maxt - durationMilliseconds(node.Range)
|
||||
matrix = make(Matrix, 0, len(vs.series))
|
||||
matrix = make(Matrix, 0, len(vs.Series))
|
||||
)
|
||||
|
||||
it := storage.NewBuffer(durationMilliseconds(node.Range))
|
||||
series := vs.series
|
||||
series := vs.Series
|
||||
|
||||
for i, s := range series {
|
||||
if err := contextDone(ev.ctx, "expression evaluation"); err != nil {
|
||||
|
|
@ -1505,7 +1505,7 @@ func (ev *evaluator) matrixIterSlice(it *storage.BufferedSeriesIterator, mint, m
|
|||
}
|
||||
// The seeked sample might also be in the range.
|
||||
if ok {
|
||||
t, v := it.parser.Values()
|
||||
t, v := it.Values()
|
||||
if t == maxt && !value.IsStaleNaN(v) {
|
||||
if ev.currentSamples >= ev.maxSamples {
|
||||
ev.error(ErrTooManySamples(env))
|
||||
|
|
@ -1518,7 +1518,7 @@ func (ev *evaluator) matrixIterSlice(it *storage.BufferedSeriesIterator, mint, m
|
|||
}
|
||||
|
||||
func (ev *evaluator) VectorAnd(lhs, rhs Vector, matching *parser.VectorMatching, enh *EvalNodeHelper) Vector {
|
||||
if matching.Card != CardManyToMany {
|
||||
if matching.Card != parser.CardManyToMany {
|
||||
panic("set operations must only use many-to-many matching")
|
||||
}
|
||||
sigf := enh.signatureFunc(matching.On, matching.MatchingLabels...)
|
||||
|
|
@ -1540,7 +1540,7 @@ func (ev *evaluator) VectorAnd(lhs, rhs Vector, matching *parser.VectorMatching,
|
|||
}
|
||||
|
||||
func (ev *evaluator) VectorOr(lhs, rhs Vector, matching *parser.VectorMatching, enh *EvalNodeHelper) Vector {
|
||||
if matching.Card != CardManyToMany {
|
||||
if matching.Card != parser.CardManyToMany {
|
||||
panic("set operations must only use many-to-many matching")
|
||||
}
|
||||
sigf := enh.signatureFunc(matching.On, matching.MatchingLabels...)
|
||||
|
|
@ -1561,7 +1561,7 @@ func (ev *evaluator) VectorOr(lhs, rhs Vector, matching *parser.VectorMatching,
|
|||
}
|
||||
|
||||
func (ev *evaluator) VectorUnless(lhs, rhs Vector, matching *parser.VectorMatching, enh *EvalNodeHelper) Vector {
|
||||
if matching.Card != CardManyToMany {
|
||||
if matching.Card != parser.CardManyToMany {
|
||||
panic("set operations must only use many-to-many matching")
|
||||
}
|
||||
sigf := enh.signatureFunc(matching.On, matching.MatchingLabels...)
|
||||
|
|
@ -1581,7 +1581,7 @@ func (ev *evaluator) VectorUnless(lhs, rhs Vector, matching *parser.VectorMatchi
|
|||
|
||||
// VectorBinop evaluates a binary operation between two Vectors, excluding set operators.
|
||||
func (ev *evaluator) VectorBinop(op parser.ItemType, lhs, rhs Vector, matching *parser.VectorMatching, returnBool bool, enh *EvalNodeHelper) Vector {
|
||||
if matching.Card == CardManyToMany {
|
||||
if matching.Card == parser.CardManyToMany {
|
||||
panic("many-to-many only allowed for set operators")
|
||||
}
|
||||
sigf := enh.signatureFunc(matching.On, matching.MatchingLabels...)
|
||||
|
|
@ -1589,7 +1589,7 @@ func (ev *evaluator) VectorBinop(op parser.ItemType, lhs, rhs Vector, matching *
|
|||
// The control flow below handles one-to-one or many-to-one matching.
|
||||
// For one-to-many, swap sidedness and account for the swap when calculating
|
||||
// values.
|
||||
if matching.Card == CardOneToMany {
|
||||
if matching.Card == parser.CardOneToMany {
|
||||
lhs, rhs = rhs, lhs
|
||||
}
|
||||
|
||||
|
|
@ -1611,7 +1611,7 @@ func (ev *evaluator) VectorBinop(op parser.ItemType, lhs, rhs Vector, matching *
|
|||
if duplSample, found := rightSigs[sig]; found {
|
||||
// oneSide represents which side of the vector represents the 'one' in the many-to-one relationship.
|
||||
oneSide := "right"
|
||||
if matching.Card == CardOneToMany {
|
||||
if matching.Card == parser.CardOneToMany {
|
||||
oneSide = "left"
|
||||
}
|
||||
matchedLabels := rs.Metric.MatchLabels(matching.On, matching.MatchingLabels...)
|
||||
|
|
@ -1645,7 +1645,7 @@ func (ev *evaluator) VectorBinop(op parser.ItemType, lhs, rhs Vector, matching *
|
|||
|
||||
// Account for potentially swapped sidedness.
|
||||
vl, vr := ls.V, rs.V
|
||||
if matching.Card == CardOneToMany {
|
||||
if matching.Card == parser.CardOneToMany {
|
||||
vl, vr = vr, vl
|
||||
}
|
||||
value, keep := vectorElemBinop(op, vl, vr)
|
||||
|
|
@ -1661,7 +1661,7 @@ func (ev *evaluator) VectorBinop(op parser.ItemType, lhs, rhs Vector, matching *
|
|||
metric := resultMetric(ls.Metric, rs.Metric, op, matching, enh)
|
||||
|
||||
insertedSigs, exists := matchedSigs[sig]
|
||||
if matching.Card == CardOneToOne {
|
||||
if matching.Card == parser.CardOneToOne {
|
||||
if exists {
|
||||
ev.errorf("multiple matches for labels: many-to-one matching must be explicit (group_left/group_right)")
|
||||
}
|
||||
|
|
@ -1727,7 +1727,7 @@ func resultMetric(lhs, rhs labels.Labels, op parser.ItemType, matching *parser.V
|
|||
lb.Del(labels.MetricName)
|
||||
}
|
||||
|
||||
if matching.Card == CardOneToOne {
|
||||
if matching.Card == parser.CardOneToOne {
|
||||
if matching.On {
|
||||
Outer:
|
||||
for _, l := range lhs {
|
||||
|
|
@ -1768,7 +1768,7 @@ func (ev *evaluator) VectorscalarBinop(op parser.ItemType, lhs Vector, rhs Scala
|
|||
value, keep := vectorElemBinop(op, lv, rv)
|
||||
// Catch cases where the scalar is the LHS in a scalar-vector comparison operation.
|
||||
// We want to always keep the vector element value as the output value, even if it's on the RHS.
|
||||
if op.isComparisonOperator() && swap {
|
||||
if op.IsComparisonOperator() && swap {
|
||||
value = rv
|
||||
}
|
||||
if returnBool {
|
||||
|
|
@ -1797,29 +1797,29 @@ func dropMetricName(l labels.Labels) labels.Labels {
|
|||
// scalarBinop evaluates a binary operation between two Scalars.
|
||||
func scalarBinop(op parser.ItemType, lhs, rhs float64) float64 {
|
||||
switch op {
|
||||
case ADD:
|
||||
case parser.ADD:
|
||||
return lhs + rhs
|
||||
case SUB:
|
||||
case parser.SUB:
|
||||
return lhs - rhs
|
||||
case MUL:
|
||||
case parser.MUL:
|
||||
return lhs * rhs
|
||||
case DIV:
|
||||
case parser.DIV:
|
||||
return lhs / rhs
|
||||
case POW:
|
||||
case parser.POW:
|
||||
return math.Pow(lhs, rhs)
|
||||
case MOD:
|
||||
case parser.MOD:
|
||||
return math.Mod(lhs, rhs)
|
||||
case EQL:
|
||||
case parser.EQL:
|
||||
return btos(lhs == rhs)
|
||||
case NEQ:
|
||||
case parser.NEQ:
|
||||
return btos(lhs != rhs)
|
||||
case GTR:
|
||||
case parser.GTR:
|
||||
return btos(lhs > rhs)
|
||||
case LSS:
|
||||
case parser.LSS:
|
||||
return btos(lhs < rhs)
|
||||
case GTE:
|
||||
case parser.GTE:
|
||||
return btos(lhs >= rhs)
|
||||
case LTE:
|
||||
case parser.LTE:
|
||||
return btos(lhs <= rhs)
|
||||
}
|
||||
panic(errors.Errorf("operator %q not allowed for Scalar operations", op))
|
||||
|
|
@ -1828,29 +1828,29 @@ func scalarBinop(op parser.ItemType, lhs, rhs float64) float64 {
|
|||
// vectorElemBinop evaluates a binary operation between two Vector elements.
|
||||
func vectorElemBinop(op parser.ItemType, lhs, rhs float64) (float64, bool) {
|
||||
switch op {
|
||||
case ADD:
|
||||
case parser.ADD:
|
||||
return lhs + rhs, true
|
||||
case SUB:
|
||||
case parser.SUB:
|
||||
return lhs - rhs, true
|
||||
case MUL:
|
||||
case parser.MUL:
|
||||
return lhs * rhs, true
|
||||
case DIV:
|
||||
case parser.DIV:
|
||||
return lhs / rhs, true
|
||||
case POW:
|
||||
case parser.POW:
|
||||
return math.Pow(lhs, rhs), true
|
||||
case MOD:
|
||||
case parser.MOD:
|
||||
return math.Mod(lhs, rhs), true
|
||||
case EQL:
|
||||
case parser.EQL:
|
||||
return lhs, lhs == rhs
|
||||
case NEQ:
|
||||
case parser.NEQ:
|
||||
return lhs, lhs != rhs
|
||||
case GTR:
|
||||
case parser.GTR:
|
||||
return lhs, lhs > rhs
|
||||
case LSS:
|
||||
case parser.LSS:
|
||||
return lhs, lhs < rhs
|
||||
case GTE:
|
||||
case parser.GTE:
|
||||
return lhs, lhs >= rhs
|
||||
case LTE:
|
||||
case parser.LTE:
|
||||
return lhs, lhs <= rhs
|
||||
}
|
||||
panic(errors.Errorf("operator %q not allowed for operations between Vectors", op))
|
||||
|
|
@ -1870,7 +1870,7 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
|
|||
|
||||
result := map[uint64]*groupedAggregation{}
|
||||
var k int64
|
||||
if op == TOPK || op == BOTTOMK {
|
||||
if op == parser.TOPK || op == parser.BOTTOMK {
|
||||
f := param.(float64)
|
||||
if !convertibleToInt64(f) {
|
||||
ev.errorf("Scalar value %v overflows int64", f)
|
||||
|
|
@ -1881,11 +1881,11 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
|
|||
}
|
||||
}
|
||||
var q float64
|
||||
if op == QUANTILE {
|
||||
if op == parser.QUANTILE {
|
||||
q = param.(float64)
|
||||
}
|
||||
var valueLabel string
|
||||
if op == COUNT_VALUES {
|
||||
if op == parser.COUNT_VALUES {
|
||||
valueLabel = param.(string)
|
||||
if !model.LabelName(valueLabel).IsValid() {
|
||||
ev.errorf("invalid label name %q", valueLabel)
|
||||
|
|
@ -1901,7 +1901,7 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
|
|||
for _, s := range vec {
|
||||
metric := s.Metric
|
||||
|
||||
if op == COUNT_VALUES {
|
||||
if op == parser.COUNT_VALUES {
|
||||
lb.Reset(metric)
|
||||
lb.Set(valueLabel, strconv.FormatFloat(s.V, 'f', -1, 64))
|
||||
metric = lb.Labels()
|
||||
|
|
@ -1949,15 +1949,15 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
|
|||
if k > inputVecLen {
|
||||
resultSize = inputVecLen
|
||||
}
|
||||
if op == STDVAR || op == STDDEV {
|
||||
if op == parser.STDVAR || op == parser.STDDEV {
|
||||
result[groupingKey].value = 0.0
|
||||
} else if op == TOPK || op == QUANTILE {
|
||||
} else if op == parser.TOPK || op == parser.QUANTILE {
|
||||
result[groupingKey].heap = make(vectorByValueHeap, 0, resultSize)
|
||||
heap.Push(&result[groupingKey].heap, &Sample{
|
||||
Point: Point{V: s.V},
|
||||
Metric: s.Metric,
|
||||
})
|
||||
} else if op == BOTTOMK {
|
||||
} else if op == parser.BOTTOMK {
|
||||
result[groupingKey].reverseHeap = make(vectorByReverseValueHeap, 0, resultSize)
|
||||
heap.Push(&result[groupingKey].reverseHeap, &Sample{
|
||||
Point: Point{V: s.V},
|
||||
|
|
@ -1968,33 +1968,33 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
|
|||
}
|
||||
|
||||
switch op {
|
||||
case SUM:
|
||||
case parser.SUM:
|
||||
group.value += s.V
|
||||
|
||||
case AVG:
|
||||
case parser.AVG:
|
||||
group.groupCount++
|
||||
group.mean += (s.V - group.mean) / float64(group.groupCount)
|
||||
|
||||
case MAX:
|
||||
case parser.MAX:
|
||||
if group.value < s.V || math.IsNaN(group.value) {
|
||||
group.value = s.V
|
||||
}
|
||||
|
||||
case MIN:
|
||||
case parser.MIN:
|
||||
if group.value > s.V || math.IsNaN(group.value) {
|
||||
group.value = s.V
|
||||
}
|
||||
|
||||
case COUNT, COUNT_VALUES:
|
||||
case parser.COUNT, parser.COUNT_VALUES:
|
||||
group.groupCount++
|
||||
|
||||
case STDVAR, STDDEV:
|
||||
case parser.STDVAR, parser.STDDEV:
|
||||
group.groupCount++
|
||||
delta := s.V - group.mean
|
||||
group.mean += delta / float64(group.groupCount)
|
||||
group.value += delta * (s.V - group.mean)
|
||||
|
||||
case TOPK:
|
||||
case parser.TOPK:
|
||||
if int64(len(group.heap)) < k || group.heap[0].V < s.V || math.IsNaN(group.heap[0].V) {
|
||||
if int64(len(group.heap)) == k {
|
||||
heap.Pop(&group.heap)
|
||||
|
|
@ -2005,7 +2005,7 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
|
|||
})
|
||||
}
|
||||
|
||||
case BOTTOMK:
|
||||
case parser.BOTTOMK:
|
||||
if int64(len(group.reverseHeap)) < k || group.reverseHeap[0].V > s.V || math.IsNaN(group.reverseHeap[0].V) {
|
||||
if int64(len(group.reverseHeap)) == k {
|
||||
heap.Pop(&group.reverseHeap)
|
||||
|
|
@ -2016,7 +2016,7 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
|
|||
})
|
||||
}
|
||||
|
||||
case QUANTILE:
|
||||
case parser.QUANTILE:
|
||||
group.heap = append(group.heap, s)
|
||||
|
||||
default:
|
||||
|
|
@ -2027,19 +2027,19 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
|
|||
// Construct the result Vector from the aggregated groups.
|
||||
for _, aggr := range result {
|
||||
switch op {
|
||||
case AVG:
|
||||
case parser.AVG:
|
||||
aggr.value = aggr.mean
|
||||
|
||||
case COUNT, COUNT_VALUES:
|
||||
case parser.COUNT, parser.COUNT_VALUES:
|
||||
aggr.value = float64(aggr.groupCount)
|
||||
|
||||
case STDVAR:
|
||||
case parser.STDVAR:
|
||||
aggr.value = aggr.value / float64(aggr.groupCount)
|
||||
|
||||
case STDDEV:
|
||||
case parser.STDDEV:
|
||||
aggr.value = math.Sqrt(aggr.value / float64(aggr.groupCount))
|
||||
|
||||
case TOPK:
|
||||
case parser.TOPK:
|
||||
// The heap keeps the lowest value on top, so reverse it.
|
||||
sort.Sort(sort.Reverse(aggr.heap))
|
||||
for _, v := range aggr.heap {
|
||||
|
|
@ -2050,7 +2050,7 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
|
|||
}
|
||||
continue // Bypass default append.
|
||||
|
||||
case BOTTOMK:
|
||||
case parser.BOTTOMK:
|
||||
// The heap keeps the lowest value on top, so reverse it.
|
||||
sort.Sort(sort.Reverse(aggr.reverseHeap))
|
||||
for _, v := range aggr.reverseHeap {
|
||||
|
|
@ -2061,7 +2061,7 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
|
|||
}
|
||||
continue // Bypass default append.
|
||||
|
||||
case QUANTILE:
|
||||
case parser.QUANTILE:
|
||||
aggr.value = quantile(q, aggr.heap)
|
||||
|
||||
default:
|
||||
|
|
@ -2088,7 +2088,7 @@ func btos(b bool) float64 {
|
|||
// result of the op operation.
|
||||
func shouldDropMetricName(op parser.ItemType) bool {
|
||||
switch op {
|
||||
case ADD, SUB, DIV, MUL, POW, MOD:
|
||||
case parser.ADD, parser.SUB, parser.DIV, parser.MUL, parser.POW, parser.MOD:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
|
|
@ -2107,8 +2107,8 @@ func formatDate(t time.Time) string {
|
|||
// unwrapParenExpr does the AST equivalent of removing parentheses around a expression.
|
||||
func unwrapParenExpr(e *parser.Expr) {
|
||||
for {
|
||||
if p, ok := (*e).(*ParenExpr); ok {
|
||||
*e = p.parser.Expr
|
||||
if p, ok := (*e).(*parser.ParenExpr); ok {
|
||||
*e = p.Expr
|
||||
} else {
|
||||
break
|
||||
}
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ func funcTime(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelper)
|
|||
// the result as either per-second (if isRate is true) or overall.
|
||||
func extrapolatedRate(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelper, isCounter bool, isRate bool) Vector {
|
||||
ms := args[0].(*parser.MatrixSelector)
|
||||
vs := ms.parser.VectorSelector.(*parser.VectorSelector)
|
||||
vs := ms.VectorSelector.(*parser.VectorSelector)
|
||||
|
||||
var (
|
||||
samples = vals[0].(Matrix)[0]
|
||||
|
|
@ -683,10 +683,10 @@ func funcChanges(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelp
|
|||
func funcLabelReplace(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelper) Vector {
|
||||
var (
|
||||
vector = vals[0].(Vector)
|
||||
dst = args[1].(*StringLiteral).Val
|
||||
repl = args[2].(*StringLiteral).Val
|
||||
src = args[3].(*StringLiteral).Val
|
||||
regexStr = args[4].(*StringLiteral).Val
|
||||
dst = args[1].(*parser.StringLiteral).Val
|
||||
repl = args[2].(*parser.StringLiteral).Val
|
||||
src = args[3].(*parser.StringLiteral).Val
|
||||
regexStr = args[4].(*parser.StringLiteral).Val
|
||||
)
|
||||
|
||||
if enh.regex == nil {
|
||||
|
|
@ -746,8 +746,8 @@ func funcVector(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelpe
|
|||
func funcLabelJoin(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelper) Vector {
|
||||
var (
|
||||
vector = vals[0].(Vector)
|
||||
dst = args[1].(*StringLiteral).Val
|
||||
sep = args[2].(*StringLiteral).Val
|
||||
dst = args[1].(*parser.StringLiteral).Val
|
||||
sep = args[2].(*parser.StringLiteral).Val
|
||||
srcLabels = make([]string, len(args)-3)
|
||||
)
|
||||
|
||||
|
|
@ -756,7 +756,7 @@ func funcLabelJoin(vals []parser.Value, args parser.Expressions, enh *EvalNodeHe
|
|||
}
|
||||
|
||||
for i := 3; i < len(args); i++ {
|
||||
src := args[i].(*StringLiteral).Val
|
||||
src := args[i].(*parser.StringLiteral).Val
|
||||
if !model.LabelName(src).IsValid() {
|
||||
panic(errors.Errorf("invalid source label name in label_join(): %s", src))
|
||||
}
|
||||
|
|
@ -889,7 +889,7 @@ var FunctionCalls = map[string]FunctionCall{
|
|||
"floor": funcFloor,
|
||||
"histogram_quantile": funcHistogramQuantile,
|
||||
"holt_winters": funcHoltWinters,
|
||||
"hour": parser.ValueTypeVector,
|
||||
"hour": funcHour,
|
||||
"idelta": funcIdelta,
|
||||
"increase": funcIncrease,
|
||||
"irate": funcIrate,
|
||||
|
|
@ -994,7 +994,7 @@ func createLabelsForAbsentFunction(expr parser.Expr) labels.Labels {
|
|||
case *parser.VectorSelector:
|
||||
lm = n.LabelMatchers
|
||||
case *parser.MatrixSelector:
|
||||
lm = n.parser.VectorSelector.(*parser.VectorSelector).LabelMatchers
|
||||
lm = n.VectorSelector.(*parser.VectorSelector).LabelMatchers
|
||||
default:
|
||||
return m
|
||||
}
|
||||
|
|
@ -1005,7 +1005,7 @@ func createLabelsForAbsentFunction(expr parser.Expr) labels.Labels {
|
|||
continue
|
||||
}
|
||||
if ma.Type == labels.MatchEqual && !m.Has(ma.Name) {
|
||||
m = labels.NewBuilder(m).Set(ma.Name, ma.parser.Value).Labels()
|
||||
m = labels.NewBuilder(m).Set(ma.Name, ma.Value).Labels()
|
||||
} else {
|
||||
empty = append(empty, ma.Name)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ import (
|
|||
label labels.Label
|
||||
labels labels.Labels
|
||||
strings []string
|
||||
series []sequenceValue
|
||||
series []SequenceValue
|
||||
uint uint64
|
||||
float float64
|
||||
duration time.Duration
|
||||
|
|
@ -577,7 +577,7 @@ series_description: metric series_values
|
|||
;
|
||||
|
||||
series_values : /*empty*/
|
||||
{ $$ = []sequenceValue{} }
|
||||
{ $$ = []SequenceValue{} }
|
||||
| series_values SPACE series_item
|
||||
{ $$ = append($1, $3...) }
|
||||
| series_values SPACE
|
||||
|
|
@ -587,28 +587,28 @@ series_values : /*empty*/
|
|||
;
|
||||
|
||||
series_item : BLANK
|
||||
{ $$ = []sequenceValue{{omitted: true}}}
|
||||
{ $$ = []SequenceValue{{Omitted: true}}}
|
||||
| BLANK TIMES uint
|
||||
{
|
||||
$$ = []sequenceValue{}
|
||||
$$ = []SequenceValue{}
|
||||
for i:=uint64(0); i < $3; i++{
|
||||
$$ = append($$, sequenceValue{omitted: true})
|
||||
$$ = append($$, SequenceValue{Omitted: true})
|
||||
}
|
||||
}
|
||||
| series_value
|
||||
{ $$ = []sequenceValue{{value: $1}}}
|
||||
{ $$ = []SequenceValue{{Value: $1}}}
|
||||
| series_value TIMES uint
|
||||
{
|
||||
$$ = []sequenceValue{}
|
||||
$$ = []SequenceValue{}
|
||||
for i:=uint64(0); i <= $3; i++{
|
||||
$$ = append($$, sequenceValue{value: $1})
|
||||
$$ = append($$, SequenceValue{Value: $1})
|
||||
}
|
||||
}
|
||||
| series_value signed_number TIMES uint
|
||||
{
|
||||
$$ = []sequenceValue{}
|
||||
$$ = []SequenceValue{}
|
||||
for i:=uint64(0); i <= $4; i++{
|
||||
$$ = append($$, sequenceValue{value: $1})
|
||||
$$ = append($$, SequenceValue{Value: $1})
|
||||
$1 += $2
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,11 +1,11 @@
|
|||
// Code generated by goyacc -o promql/generated_parser.y.go promql/generated_parser.y. DO NOT EDIT.
|
||||
// Code generated by goyacc -o generated_parser.y.go generated_parser.y. DO NOT EDIT.
|
||||
|
||||
//line promql/generated_parser.y:15
|
||||
//line generated_parser.y:15
|
||||
package parser
|
||||
|
||||
import __yyfmt__ "fmt"
|
||||
|
||||
//line promql/generated_parser.y:15
|
||||
//line generated_parser.y:15
|
||||
|
||||
import (
|
||||
"math"
|
||||
|
|
@ -17,7 +17,7 @@ import (
|
|||
"github.com/prometheus/prometheus/pkg/value"
|
||||
)
|
||||
|
||||
//line promql/generated_parser.y:28
|
||||
//line generated_parser.y:28
|
||||
type yySymType struct {
|
||||
yys int
|
||||
node Node
|
||||
|
|
@ -183,7 +183,7 @@ const yyEofCode = 1
|
|||
const yyErrCode = 2
|
||||
const yyInitialStackSize = 16
|
||||
|
||||
//line promql/generated_parser.y:706
|
||||
//line generated_parser.y:706
|
||||
|
||||
//line yacctab:1
|
||||
var yyExca = [...]int{
|
||||
|
|
@ -786,62 +786,62 @@ yydefault:
|
|||
|
||||
case 1:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:164
|
||||
//line generated_parser.y:164
|
||||
{
|
||||
yylex.(*parser).generatedParserResult = yyDollar[2].labels
|
||||
}
|
||||
case 3:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:167
|
||||
//line generated_parser.y:167
|
||||
{
|
||||
yylex.(*parser).addParseErrf(PositionRange{}, "no expression found in input")
|
||||
}
|
||||
case 4:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:169
|
||||
//line generated_parser.y:169
|
||||
{
|
||||
yylex.(*parser).generatedParserResult = yyDollar[2].node
|
||||
}
|
||||
case 5:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:171
|
||||
//line generated_parser.y:171
|
||||
{
|
||||
yylex.(*parser).generatedParserResult = yyDollar[2].node
|
||||
}
|
||||
case 7:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:174
|
||||
//line generated_parser.y:174
|
||||
{
|
||||
yylex.(*parser).unexpected("", "")
|
||||
}
|
||||
case 19:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:196
|
||||
//line generated_parser.y:196
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newAggregateExpr(yyDollar[1].item, yyDollar[2].node, yyDollar[3].node)
|
||||
}
|
||||
case 20:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:198
|
||||
//line generated_parser.y:198
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newAggregateExpr(yyDollar[1].item, yyDollar[3].node, yyDollar[2].node)
|
||||
}
|
||||
case 21:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:200
|
||||
//line generated_parser.y:200
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newAggregateExpr(yyDollar[1].item, &AggregateExpr{}, yyDollar[2].node)
|
||||
}
|
||||
case 22:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:202
|
||||
//line generated_parser.y:202
|
||||
{
|
||||
yylex.(*parser).unexpected("aggregation", "")
|
||||
yyVAL.node = nil
|
||||
}
|
||||
case 23:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:207
|
||||
//line generated_parser.y:207
|
||||
{
|
||||
yyVAL.node = &AggregateExpr{
|
||||
Grouping: yyDollar[2].strings,
|
||||
|
|
@ -849,7 +849,7 @@ yydefault:
|
|||
}
|
||||
case 24:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:213
|
||||
//line generated_parser.y:213
|
||||
{
|
||||
yyVAL.node = &AggregateExpr{
|
||||
Grouping: yyDollar[2].strings,
|
||||
|
|
@ -858,97 +858,97 @@ yydefault:
|
|||
}
|
||||
case 25:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:226
|
||||
//line generated_parser.y:226
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
|
||||
}
|
||||
case 26:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:227
|
||||
//line generated_parser.y:227
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
|
||||
}
|
||||
case 27:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:228
|
||||
//line generated_parser.y:228
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
|
||||
}
|
||||
case 28:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:229
|
||||
//line generated_parser.y:229
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
|
||||
}
|
||||
case 29:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:230
|
||||
//line generated_parser.y:230
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
|
||||
}
|
||||
case 30:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:231
|
||||
//line generated_parser.y:231
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
|
||||
}
|
||||
case 31:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:232
|
||||
//line generated_parser.y:232
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
|
||||
}
|
||||
case 32:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:233
|
||||
//line generated_parser.y:233
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
|
||||
}
|
||||
case 33:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:234
|
||||
//line generated_parser.y:234
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
|
||||
}
|
||||
case 34:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:235
|
||||
//line generated_parser.y:235
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
|
||||
}
|
||||
case 35:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:236
|
||||
//line generated_parser.y:236
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
|
||||
}
|
||||
case 36:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:237
|
||||
//line generated_parser.y:237
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
|
||||
}
|
||||
case 37:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:238
|
||||
//line generated_parser.y:238
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
|
||||
}
|
||||
case 38:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:239
|
||||
//line generated_parser.y:239
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
|
||||
}
|
||||
case 39:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:240
|
||||
//line generated_parser.y:240
|
||||
{
|
||||
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
|
||||
}
|
||||
case 41:
|
||||
yyDollar = yyS[yypt-0 : yypt+1]
|
||||
//line promql/generated_parser.y:248
|
||||
//line generated_parser.y:248
|
||||
{
|
||||
yyVAL.node = &BinaryExpr{
|
||||
VectorMatching: &VectorMatching{Card: CardOneToOne},
|
||||
|
|
@ -956,7 +956,7 @@ yydefault:
|
|||
}
|
||||
case 42:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:253
|
||||
//line generated_parser.y:253
|
||||
{
|
||||
yyVAL.node = &BinaryExpr{
|
||||
VectorMatching: &VectorMatching{Card: CardOneToOne},
|
||||
|
|
@ -965,14 +965,14 @@ yydefault:
|
|||
}
|
||||
case 43:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:261
|
||||
//line generated_parser.y:261
|
||||
{
|
||||
yyVAL.node = yyDollar[1].node
|
||||
yyVAL.node.(*BinaryExpr).VectorMatching.MatchingLabels = yyDollar[3].strings
|
||||
}
|
||||
case 44:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:266
|
||||
//line generated_parser.y:266
|
||||
{
|
||||
yyVAL.node = yyDollar[1].node
|
||||
yyVAL.node.(*BinaryExpr).VectorMatching.MatchingLabels = yyDollar[3].strings
|
||||
|
|
@ -980,7 +980,7 @@ yydefault:
|
|||
}
|
||||
case 47:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:276
|
||||
//line generated_parser.y:276
|
||||
{
|
||||
yyVAL.node = yyDollar[1].node
|
||||
yyVAL.node.(*BinaryExpr).VectorMatching.Card = CardManyToOne
|
||||
|
|
@ -988,7 +988,7 @@ yydefault:
|
|||
}
|
||||
case 48:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:282
|
||||
//line generated_parser.y:282
|
||||
{
|
||||
yyVAL.node = yyDollar[1].node
|
||||
yyVAL.node.(*BinaryExpr).VectorMatching.Card = CardOneToMany
|
||||
|
|
@ -996,51 +996,51 @@ yydefault:
|
|||
}
|
||||
case 49:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:291
|
||||
//line generated_parser.y:291
|
||||
{
|
||||
yyVAL.strings = yyDollar[2].strings
|
||||
}
|
||||
case 50:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:293
|
||||
//line generated_parser.y:293
|
||||
{
|
||||
yyVAL.strings = yyDollar[2].strings
|
||||
}
|
||||
case 51:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:295
|
||||
//line generated_parser.y:295
|
||||
{
|
||||
yyVAL.strings = []string{}
|
||||
}
|
||||
case 52:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:297
|
||||
//line generated_parser.y:297
|
||||
{
|
||||
yylex.(*parser).unexpected("grouping opts", "\"(\"")
|
||||
yyVAL.strings = nil
|
||||
}
|
||||
case 53:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:303
|
||||
//line generated_parser.y:303
|
||||
{
|
||||
yyVAL.strings = append(yyDollar[1].strings, yyDollar[3].item.Val)
|
||||
}
|
||||
case 54:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:305
|
||||
//line generated_parser.y:305
|
||||
{
|
||||
yyVAL.strings = []string{yyDollar[1].item.Val}
|
||||
}
|
||||
case 55:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:307
|
||||
//line generated_parser.y:307
|
||||
{
|
||||
yylex.(*parser).unexpected("grouping opts", "\",\" or \")\"")
|
||||
yyVAL.strings = yyDollar[1].strings
|
||||
}
|
||||
case 56:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:311
|
||||
//line generated_parser.y:311
|
||||
{
|
||||
if !isLabel(yyDollar[1].item.Val) {
|
||||
yylex.(*parser).unexpected("grouping opts", "label")
|
||||
|
|
@ -1049,14 +1049,14 @@ yydefault:
|
|||
}
|
||||
case 57:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:318
|
||||
//line generated_parser.y:318
|
||||
{
|
||||
yylex.(*parser).unexpected("grouping opts", "label")
|
||||
yyVAL.item = Item{}
|
||||
}
|
||||
case 58:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:326
|
||||
//line generated_parser.y:326
|
||||
{
|
||||
fn, exist := getFunction(yyDollar[1].item.Val)
|
||||
if !exist {
|
||||
|
|
@ -1073,58 +1073,58 @@ yydefault:
|
|||
}
|
||||
case 59:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:343
|
||||
//line generated_parser.y:343
|
||||
{
|
||||
yyVAL.node = yyDollar[2].node
|
||||
}
|
||||
case 60:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:345
|
||||
//line generated_parser.y:345
|
||||
{
|
||||
yyVAL.node = Expressions{}
|
||||
}
|
||||
case 61:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:349
|
||||
//line generated_parser.y:349
|
||||
{
|
||||
yyVAL.node = append(yyDollar[1].node.(Expressions), yyDollar[3].node.(Expr))
|
||||
}
|
||||
case 62:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:351
|
||||
//line generated_parser.y:351
|
||||
{
|
||||
yyVAL.node = Expressions{yyDollar[1].node.(Expr)}
|
||||
}
|
||||
case 63:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:353
|
||||
//line generated_parser.y:353
|
||||
{
|
||||
yylex.(*parser).addParseErrf(yyDollar[2].item.PositionRange(), "trailing commas not allowed in function call args")
|
||||
yyVAL.node = yyDollar[1].node
|
||||
}
|
||||
case 64:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:364
|
||||
//line generated_parser.y:364
|
||||
{
|
||||
yyVAL.node = &ParenExpr{Expr: yyDollar[2].node.(Expr), PosRange: mergeRanges(&yyDollar[1].item, &yyDollar[3].item)}
|
||||
}
|
||||
case 65:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:372
|
||||
//line generated_parser.y:372
|
||||
{
|
||||
yylex.(*parser).addOffset(yyDollar[1].node, yyDollar[3].duration)
|
||||
yyVAL.node = yyDollar[1].node
|
||||
}
|
||||
case 66:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:377
|
||||
//line generated_parser.y:377
|
||||
{
|
||||
yylex.(*parser).unexpected("offset", "duration")
|
||||
yyVAL.node = yyDollar[1].node
|
||||
}
|
||||
case 67:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:385
|
||||
//line generated_parser.y:385
|
||||
{
|
||||
var errMsg string
|
||||
vs, ok := yyDollar[1].node.(*VectorSelector)
|
||||
|
|
@ -1147,7 +1147,7 @@ yydefault:
|
|||
}
|
||||
case 68:
|
||||
yyDollar = yyS[yypt-6 : yypt+1]
|
||||
//line promql/generated_parser.y:408
|
||||
//line generated_parser.y:408
|
||||
{
|
||||
yyVAL.node = &SubqueryExpr{
|
||||
Expr: yyDollar[1].node.(Expr),
|
||||
|
|
@ -1159,35 +1159,35 @@ yydefault:
|
|||
}
|
||||
case 69:
|
||||
yyDollar = yyS[yypt-6 : yypt+1]
|
||||
//line promql/generated_parser.y:418
|
||||
//line generated_parser.y:418
|
||||
{
|
||||
yylex.(*parser).unexpected("subquery selector", "\"]\"")
|
||||
yyVAL.node = yyDollar[1].node
|
||||
}
|
||||
case 70:
|
||||
yyDollar = yyS[yypt-5 : yypt+1]
|
||||
//line promql/generated_parser.y:420
|
||||
//line generated_parser.y:420
|
||||
{
|
||||
yylex.(*parser).unexpected("subquery selector", "duration or \"]\"")
|
||||
yyVAL.node = yyDollar[1].node
|
||||
}
|
||||
case 71:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:422
|
||||
//line generated_parser.y:422
|
||||
{
|
||||
yylex.(*parser).unexpected("subquery or range", "\":\" or \"]\"")
|
||||
yyVAL.node = yyDollar[1].node
|
||||
}
|
||||
case 72:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:424
|
||||
//line generated_parser.y:424
|
||||
{
|
||||
yylex.(*parser).unexpected("subquery selector", "duration")
|
||||
yyVAL.node = yyDollar[1].node
|
||||
}
|
||||
case 73:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:434
|
||||
//line generated_parser.y:434
|
||||
{
|
||||
if nl, ok := yyDollar[2].node.(*NumberLiteral); ok {
|
||||
if yyDollar[1].item.Typ == SUB {
|
||||
|
|
@ -1201,7 +1201,7 @@ yydefault:
|
|||
}
|
||||
case 74:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:452
|
||||
//line generated_parser.y:452
|
||||
{
|
||||
vs := yyDollar[2].node.(*VectorSelector)
|
||||
vs.PosRange = mergeRanges(&yyDollar[1].item, vs)
|
||||
|
|
@ -1211,7 +1211,7 @@ yydefault:
|
|||
}
|
||||
case 75:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:460
|
||||
//line generated_parser.y:460
|
||||
{
|
||||
vs := &VectorSelector{
|
||||
Name: yyDollar[1].item.Val,
|
||||
|
|
@ -1223,7 +1223,7 @@ yydefault:
|
|||
}
|
||||
case 76:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:470
|
||||
//line generated_parser.y:470
|
||||
{
|
||||
vs := yyDollar[1].node.(*VectorSelector)
|
||||
yylex.(*parser).assembleVectorSelector(vs)
|
||||
|
|
@ -1231,7 +1231,7 @@ yydefault:
|
|||
}
|
||||
case 77:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:478
|
||||
//line generated_parser.y:478
|
||||
{
|
||||
yyVAL.node = &VectorSelector{
|
||||
LabelMatchers: yyDollar[2].matchers,
|
||||
|
|
@ -1240,7 +1240,7 @@ yydefault:
|
|||
}
|
||||
case 78:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:485
|
||||
//line generated_parser.y:485
|
||||
{
|
||||
yyVAL.node = &VectorSelector{
|
||||
LabelMatchers: yyDollar[2].matchers,
|
||||
|
|
@ -1249,7 +1249,7 @@ yydefault:
|
|||
}
|
||||
case 79:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:492
|
||||
//line generated_parser.y:492
|
||||
{
|
||||
yyVAL.node = &VectorSelector{
|
||||
LabelMatchers: []*labels.Matcher{},
|
||||
|
|
@ -1258,7 +1258,7 @@ yydefault:
|
|||
}
|
||||
case 80:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:501
|
||||
//line generated_parser.y:501
|
||||
{
|
||||
if yyDollar[1].matchers != nil {
|
||||
yyVAL.matchers = append(yyDollar[1].matchers, yyDollar[3].matcher)
|
||||
|
|
@ -1268,130 +1268,130 @@ yydefault:
|
|||
}
|
||||
case 81:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:509
|
||||
//line generated_parser.y:509
|
||||
{
|
||||
yyVAL.matchers = []*labels.Matcher{yyDollar[1].matcher}
|
||||
}
|
||||
case 82:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:511
|
||||
//line generated_parser.y:511
|
||||
{
|
||||
yylex.(*parser).unexpected("label matching", "\",\" or \"}\"")
|
||||
yyVAL.matchers = yyDollar[1].matchers
|
||||
}
|
||||
case 83:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:515
|
||||
//line generated_parser.y:515
|
||||
{
|
||||
yyVAL.matcher = yylex.(*parser).newLabelMatcher(yyDollar[1].item, yyDollar[2].item, yyDollar[3].item)
|
||||
}
|
||||
case 84:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:517
|
||||
//line generated_parser.y:517
|
||||
{
|
||||
yylex.(*parser).unexpected("label matching", "string")
|
||||
yyVAL.matcher = nil
|
||||
}
|
||||
case 85:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:519
|
||||
//line generated_parser.y:519
|
||||
{
|
||||
yylex.(*parser).unexpected("label matching", "label matching operator")
|
||||
yyVAL.matcher = nil
|
||||
}
|
||||
case 86:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:521
|
||||
//line generated_parser.y:521
|
||||
{
|
||||
yylex.(*parser).unexpected("label matching", "identifier or \"}\"")
|
||||
yyVAL.matcher = nil
|
||||
}
|
||||
case 87:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:529
|
||||
//line generated_parser.y:529
|
||||
{
|
||||
yyVAL.labels = append(yyDollar[2].labels, labels.Label{Name: labels.MetricName, Value: yyDollar[1].item.Val})
|
||||
sort.Sort(yyVAL.labels)
|
||||
}
|
||||
case 88:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:531
|
||||
//line generated_parser.y:531
|
||||
{
|
||||
yyVAL.labels = yyDollar[1].labels
|
||||
}
|
||||
case 91:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:538
|
||||
//line generated_parser.y:538
|
||||
{
|
||||
yyVAL.labels = labels.New(yyDollar[2].labels...)
|
||||
}
|
||||
case 92:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:540
|
||||
//line generated_parser.y:540
|
||||
{
|
||||
yyVAL.labels = labels.New(yyDollar[2].labels...)
|
||||
}
|
||||
case 93:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:542
|
||||
//line generated_parser.y:542
|
||||
{
|
||||
yyVAL.labels = labels.New()
|
||||
}
|
||||
case 94:
|
||||
yyDollar = yyS[yypt-0 : yypt+1]
|
||||
//line promql/generated_parser.y:544
|
||||
//line generated_parser.y:544
|
||||
{
|
||||
yyVAL.labels = labels.New()
|
||||
}
|
||||
case 95:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:548
|
||||
//line generated_parser.y:548
|
||||
{
|
||||
yyVAL.labels = append(yyDollar[1].labels, yyDollar[3].label)
|
||||
}
|
||||
case 96:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:550
|
||||
//line generated_parser.y:550
|
||||
{
|
||||
yyVAL.labels = []labels.Label{yyDollar[1].label}
|
||||
}
|
||||
case 97:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:552
|
||||
//line generated_parser.y:552
|
||||
{
|
||||
yylex.(*parser).unexpected("label set", "\",\" or \"}\"")
|
||||
yyVAL.labels = yyDollar[1].labels
|
||||
}
|
||||
case 98:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:557
|
||||
//line generated_parser.y:557
|
||||
{
|
||||
yyVAL.label = labels.Label{Name: yyDollar[1].item.Val, Value: yylex.(*parser).unquoteString(yyDollar[3].item.Val)}
|
||||
}
|
||||
case 99:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:559
|
||||
//line generated_parser.y:559
|
||||
{
|
||||
yylex.(*parser).unexpected("label set", "string")
|
||||
yyVAL.label = labels.Label{}
|
||||
}
|
||||
case 100:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:561
|
||||
//line generated_parser.y:561
|
||||
{
|
||||
yylex.(*parser).unexpected("label set", "\"=\"")
|
||||
yyVAL.label = labels.Label{}
|
||||
}
|
||||
case 101:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:563
|
||||
//line generated_parser.y:563
|
||||
{
|
||||
yylex.(*parser).unexpected("label set", "identifier or \"}\"")
|
||||
yyVAL.label = labels.Label{}
|
||||
}
|
||||
case 102:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:571
|
||||
//line generated_parser.y:571
|
||||
{
|
||||
yylex.(*parser).generatedParserResult = &seriesDescription{
|
||||
labels: yyDollar[1].labels,
|
||||
|
|
@ -1400,72 +1400,72 @@ yydefault:
|
|||
}
|
||||
case 103:
|
||||
yyDollar = yyS[yypt-0 : yypt+1]
|
||||
//line promql/generated_parser.y:580
|
||||
//line generated_parser.y:580
|
||||
{
|
||||
yyVAL.series = []SequenceValue{}
|
||||
}
|
||||
case 104:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:582
|
||||
//line generated_parser.y:582
|
||||
{
|
||||
yyVAL.series = append(yyDollar[1].series, yyDollar[3].series...)
|
||||
}
|
||||
case 105:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:584
|
||||
//line generated_parser.y:584
|
||||
{
|
||||
yyVAL.series = yyDollar[1].series
|
||||
}
|
||||
case 106:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:586
|
||||
//line generated_parser.y:586
|
||||
{
|
||||
yylex.(*parser).unexpected("series values", "")
|
||||
yyVAL.series = nil
|
||||
}
|
||||
case 107:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:590
|
||||
//line generated_parser.y:590
|
||||
{
|
||||
yyVAL.series = []SequenceValue{{omitted: true}}
|
||||
yyVAL.series = []SequenceValue{{Omitted: true}}
|
||||
}
|
||||
case 108:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:592
|
||||
//line generated_parser.y:592
|
||||
{
|
||||
yyVAL.series = []SequenceValue{}
|
||||
for i := uint64(0); i < yyDollar[3].uint; i++ {
|
||||
yyVAL.series = append(yyVAL.series, SequenceValue{omitted: true})
|
||||
yyVAL.series = append(yyVAL.series, SequenceValue{Omitted: true})
|
||||
}
|
||||
}
|
||||
case 109:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:599
|
||||
//line generated_parser.y:599
|
||||
{
|
||||
yyVAL.series = []SequenceValue{{value: yyDollar[1].float}}
|
||||
yyVAL.series = []SequenceValue{{Value: yyDollar[1].float}}
|
||||
}
|
||||
case 110:
|
||||
yyDollar = yyS[yypt-3 : yypt+1]
|
||||
//line promql/generated_parser.y:601
|
||||
//line generated_parser.y:601
|
||||
{
|
||||
yyVAL.series = []SequenceValue{}
|
||||
for i := uint64(0); i <= yyDollar[3].uint; i++ {
|
||||
yyVAL.series = append(yyVAL.series, SequenceValue{value: yyDollar[1].float})
|
||||
yyVAL.series = append(yyVAL.series, SequenceValue{Value: yyDollar[1].float})
|
||||
}
|
||||
}
|
||||
case 111:
|
||||
yyDollar = yyS[yypt-4 : yypt+1]
|
||||
//line promql/generated_parser.y:608
|
||||
//line generated_parser.y:608
|
||||
{
|
||||
yyVAL.series = []SequenceValue{}
|
||||
for i := uint64(0); i <= yyDollar[4].uint; i++ {
|
||||
yyVAL.series = append(yyVAL.series, SequenceValue{value: yyDollar[1].float})
|
||||
yyVAL.series = append(yyVAL.series, SequenceValue{Value: yyDollar[1].float})
|
||||
yyDollar[1].float += yyDollar[2].float
|
||||
}
|
||||
}
|
||||
case 112:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:618
|
||||
//line generated_parser.y:618
|
||||
{
|
||||
if yyDollar[1].item.Val != "stale" {
|
||||
yylex.(*parser).unexpected("series values", "number or \"stale\"")
|
||||
|
|
@ -1474,7 +1474,7 @@ yydefault:
|
|||
}
|
||||
case 155:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:649
|
||||
//line generated_parser.y:649
|
||||
{
|
||||
yyVAL.node = &NumberLiteral{
|
||||
Val: yylex.(*parser).number(yyDollar[1].item.Val),
|
||||
|
|
@ -1483,25 +1483,25 @@ yydefault:
|
|||
}
|
||||
case 156:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:657
|
||||
//line generated_parser.y:657
|
||||
{
|
||||
yyVAL.float = yylex.(*parser).number(yyDollar[1].item.Val)
|
||||
}
|
||||
case 157:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:659
|
||||
//line generated_parser.y:659
|
||||
{
|
||||
yyVAL.float = yyDollar[2].float
|
||||
}
|
||||
case 158:
|
||||
yyDollar = yyS[yypt-2 : yypt+1]
|
||||
//line promql/generated_parser.y:660
|
||||
//line generated_parser.y:660
|
||||
{
|
||||
yyVAL.float = -yyDollar[2].float
|
||||
}
|
||||
case 159:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:664
|
||||
//line generated_parser.y:664
|
||||
{
|
||||
var err error
|
||||
yyVAL.uint, err = strconv.ParseUint(yyDollar[1].item.Val, 10, 64)
|
||||
|
|
@ -1511,7 +1511,7 @@ yydefault:
|
|||
}
|
||||
case 160:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:674
|
||||
//line generated_parser.y:674
|
||||
{
|
||||
var err error
|
||||
yyVAL.duration, err = parseDuration(yyDollar[1].item.Val)
|
||||
|
|
@ -1521,7 +1521,7 @@ yydefault:
|
|||
}
|
||||
case 161:
|
||||
yyDollar = yyS[yypt-1 : yypt+1]
|
||||
//line promql/generated_parser.y:685
|
||||
//line generated_parser.y:685
|
||||
{
|
||||
yyVAL.node = &StringLiteral{
|
||||
Val: yylex.(*parser).unquoteString(yyDollar[1].item.Val),
|
||||
|
|
@ -1530,13 +1530,13 @@ yydefault:
|
|||
}
|
||||
case 162:
|
||||
yyDollar = yyS[yypt-0 : yypt+1]
|
||||
//line promql/generated_parser.y:698
|
||||
//line generated_parser.y:698
|
||||
{
|
||||
yyVAL.duration = 0
|
||||
}
|
||||
case 164:
|
||||
yyDollar = yyS[yypt-0 : yypt+1]
|
||||
//line promql/generated_parser.y:702
|
||||
//line generated_parser.y:702
|
||||
{
|
||||
yyVAL.strings = nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,11 +36,11 @@ func (i Item) String() string {
|
|||
return i.Val
|
||||
case i.Typ == IDENTIFIER || i.Typ == METRIC_IDENTIFIER:
|
||||
return fmt.Sprintf("%q", i.Val)
|
||||
case i.Typ.isKeyword():
|
||||
case i.Typ.IsKeyword():
|
||||
return fmt.Sprintf("<%s>", i.Val)
|
||||
case i.Typ.isOperator():
|
||||
case i.Typ.IsOperator():
|
||||
return fmt.Sprintf("<op:%s>", i.Val)
|
||||
case i.Typ.isAggregator():
|
||||
case i.Typ.IsAggregator():
|
||||
return fmt.Sprintf("<aggr:%s>", i.Val)
|
||||
case len(i.Val) > 10:
|
||||
return fmt.Sprintf("%.10q...", i.Val)
|
||||
|
|
@ -50,25 +50,25 @@ func (i Item) String() string {
|
|||
|
||||
// isOperator returns true if the Item corresponds to a arithmetic or set operator.
|
||||
// Returns false otherwise.
|
||||
func (i ItemType) isOperator() bool { return i > operatorsStart && i < operatorsEnd }
|
||||
func (i ItemType) IsOperator() bool { return i > operatorsStart && i < operatorsEnd }
|
||||
|
||||
// isAggregator returns true if the Item belongs to the aggregator functions.
|
||||
// Returns false otherwise
|
||||
func (i ItemType) isAggregator() bool { return i > aggregatorsStart && i < aggregatorsEnd }
|
||||
func (i ItemType) IsAggregator() bool { return i > aggregatorsStart && i < aggregatorsEnd }
|
||||
|
||||
// isAggregator returns true if the Item is an aggregator that takes a parameter.
|
||||
// Returns false otherwise
|
||||
func (i ItemType) isAggregatorWithParam() bool {
|
||||
func (i ItemType) IsAggregatorWithParam() bool {
|
||||
return i == TOPK || i == BOTTOMK || i == COUNT_VALUES || i == QUANTILE
|
||||
}
|
||||
|
||||
// isKeyword returns true if the Item corresponds to a keyword.
|
||||
// Returns false otherwise.
|
||||
func (i ItemType) isKeyword() bool { return i > keywordsStart && i < keywordsEnd }
|
||||
func (i ItemType) IsKeyword() bool { return i > keywordsStart && i < keywordsEnd }
|
||||
|
||||
// isComparisonOperator returns true if the Item corresponds to a comparison operator.
|
||||
// IsComparisonOperator returns true if the Item corresponds to a comparison operator.
|
||||
// Returns false otherwise.
|
||||
func (i ItemType) isComparisonOperator() bool {
|
||||
func (i ItemType) IsComparisonOperator() bool {
|
||||
switch i {
|
||||
case EQL, NEQ, LTE, LSS, GTE, GTR:
|
||||
return true
|
||||
|
|
@ -78,7 +78,7 @@ func (i ItemType) isComparisonOperator() bool {
|
|||
}
|
||||
|
||||
// isSetOperator returns whether the Item corresponds to a set operator.
|
||||
func (i ItemType) isSetOperator() bool {
|
||||
func (i ItemType) IsSetOperator() bool {
|
||||
switch i {
|
||||
case LAND, LOR, LUNLESS:
|
||||
return true
|
||||
|
|
|
|||
|
|
@ -57,14 +57,14 @@ type ParseErr struct {
|
|||
Err error
|
||||
Query string
|
||||
|
||||
// An additional line offset to be added. Only used inside unit tests.
|
||||
lineOffset int
|
||||
// LineOffset is an additional line offset to be added. Only used inside unit tests.
|
||||
LineOffset int
|
||||
}
|
||||
|
||||
func (e *ParseErr) Error() string {
|
||||
pos := int(e.PositionRange.Start)
|
||||
lastLineBreak := -1
|
||||
line := e.lineOffset + 1
|
||||
line := e.LineOffset + 1
|
||||
|
||||
var positionStr string
|
||||
|
||||
|
|
@ -180,15 +180,15 @@ func newParser(input string) *parser {
|
|||
|
||||
// SequenceValue is an omittable value in a sequence of time series values.
|
||||
type SequenceValue struct {
|
||||
value float64
|
||||
omitted bool
|
||||
Value float64
|
||||
Omitted bool
|
||||
}
|
||||
|
||||
func (v SequenceValue) String() string {
|
||||
if v.omitted {
|
||||
if v.Omitted {
|
||||
return "_"
|
||||
}
|
||||
return fmt.Sprintf("%f", v.value)
|
||||
return fmt.Sprintf("%f", v.Value)
|
||||
}
|
||||
|
||||
type seriesDescription struct {
|
||||
|
|
@ -196,8 +196,8 @@ type seriesDescription struct {
|
|||
values []SequenceValue
|
||||
}
|
||||
|
||||
// parseSeriesDesc parses the description of a time series.
|
||||
func parseSeriesDesc(input string) (labels labels.Labels, values []SequenceValue, err error) {
|
||||
// ParseSeriesDesc parses the description of a time series.
|
||||
func ParseSeriesDesc(input string) (labels labels.Labels, values []SequenceValue, err error) {
|
||||
p := newParser(input)
|
||||
p.lex.seriesDesc = true
|
||||
|
||||
|
|
@ -382,7 +382,7 @@ func (p *parser) newAggregateExpr(op Item, modifier Node, args Node) (ret *Aggre
|
|||
}
|
||||
|
||||
desiredArgs := 1
|
||||
if ret.Op.isAggregatorWithParam() {
|
||||
if ret.Op.IsAggregatorWithParam() {
|
||||
desiredArgs = 2
|
||||
|
||||
ret.Param = arguments[0]
|
||||
|
|
@ -450,7 +450,7 @@ func (p *parser) checkAST(node Node) (typ ValueType) {
|
|||
}
|
||||
}
|
||||
case *AggregateExpr:
|
||||
if !n.Op.isAggregator() {
|
||||
if !n.Op.IsAggregator() {
|
||||
p.addParseErrf(n.PositionRange(), "aggregation operator expected in aggregation expression but got %q", n.Op)
|
||||
}
|
||||
p.expectType(n.Expr, ValueTypeVector, "aggregation expression")
|
||||
|
|
@ -476,15 +476,15 @@ func (p *parser) checkAST(node Node) (typ ValueType) {
|
|||
return
|
||||
}
|
||||
|
||||
if n.ReturnBool && !n.Op.isComparisonOperator() {
|
||||
if n.ReturnBool && !n.Op.IsComparisonOperator() {
|
||||
p.addParseErrf(opRange(), "bool modifier can only be used on comparison operators")
|
||||
}
|
||||
|
||||
if n.Op.isComparisonOperator() && !n.ReturnBool && n.RHS.Type() == ValueTypeScalar && n.LHS.Type() == ValueTypeScalar {
|
||||
if n.Op.IsComparisonOperator() && !n.ReturnBool && n.RHS.Type() == ValueTypeScalar && n.LHS.Type() == ValueTypeScalar {
|
||||
p.addParseErrf(opRange(), "comparisons between scalars must use BOOL modifier")
|
||||
}
|
||||
|
||||
if n.Op.isSetOperator() && n.VectorMatching.Card == CardOneToOne {
|
||||
if n.Op.IsSetOperator() && n.VectorMatching.Card == CardOneToOne {
|
||||
n.VectorMatching.Card = CardManyToMany
|
||||
}
|
||||
|
||||
|
|
@ -496,7 +496,7 @@ func (p *parser) checkAST(node Node) (typ ValueType) {
|
|||
}
|
||||
}
|
||||
|
||||
if !n.Op.isOperator() {
|
||||
if !n.Op.IsOperator() {
|
||||
p.addParseErrf(n.PositionRange(), "binary expression does not support operator %q", n.Op)
|
||||
}
|
||||
if lt != ValueTypeScalar && lt != ValueTypeVector {
|
||||
|
|
@ -513,7 +513,7 @@ func (p *parser) checkAST(node Node) (typ ValueType) {
|
|||
n.VectorMatching = nil
|
||||
} else {
|
||||
// Both operands are Vectors.
|
||||
if n.Op.isSetOperator() {
|
||||
if n.Op.IsSetOperator() {
|
||||
if n.VectorMatching.Card == CardOneToMany || n.VectorMatching.Card == CardManyToOne {
|
||||
p.addParseErrf(n.PositionRange(), "no grouping allowed for %q operation", n.Op)
|
||||
}
|
||||
|
|
@ -523,7 +523,7 @@ func (p *parser) checkAST(node Node) (typ ValueType) {
|
|||
}
|
||||
}
|
||||
|
||||
if (lt == ValueTypeScalar || rt == ValueTypeScalar) && n.Op.isSetOperator() {
|
||||
if (lt == ValueTypeScalar || rt == ValueTypeScalar) && n.Op.IsSetOperator() {
|
||||
p.addParseErrf(n.PositionRange(), "set operator %q not allowed in binary scalar expression", n.Op)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2615,7 +2615,7 @@ func newSeq(vals ...float64) (res []SequenceValue) {
|
|||
|
||||
func TestParseSeries(t *testing.T) {
|
||||
for _, test := range testSeries {
|
||||
metric, vals, err := parseSeriesDesc(test.input)
|
||||
metric, vals, err := ParseSeriesDesc(test.input)
|
||||
|
||||
// Unexpected errors are always caused by a bug.
|
||||
testutil.Assert(t, err != errUnexpected, "unexpected error occurred")
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ func (node *AggregateExpr) String() string {
|
|||
}
|
||||
|
||||
aggrString += "("
|
||||
if node.Op.isAggregatorWithParam() {
|
||||
if node.Op.IsAggregatorWithParam() {
|
||||
aggrString += fmt.Sprintf("%s, ", node.Param)
|
||||
}
|
||||
aggrString += fmt.Sprintf("%s)", node.Expr)
|
||||
|
|
|
|||
|
|
@ -103,7 +103,7 @@ func (t *Test) Storage() storage.Storage {
|
|||
|
||||
func raise(line int, format string, v ...interface{}) error {
|
||||
return &parser.ParseErr{
|
||||
lineOffset: line,
|
||||
LineOffset: line,
|
||||
Err: errors.Errorf(format, v...),
|
||||
}
|
||||
}
|
||||
|
|
@ -114,7 +114,7 @@ func parseLoad(lines []string, i int) (int, *loadCmd, error) {
|
|||
}
|
||||
parts := patLoad.FindStringSubmatch(lines[i])
|
||||
|
||||
gap, err := model.parser.ParseDuration(parts[1])
|
||||
gap, err := model.ParseDuration(parts[1])
|
||||
if err != nil {
|
||||
return i, nil, raise(i, "invalid step definition %q: %s", parts[1], err)
|
||||
}
|
||||
|
|
@ -126,10 +126,10 @@ func parseLoad(lines []string, i int) (int, *loadCmd, error) {
|
|||
i--
|
||||
break
|
||||
}
|
||||
metric, vals, err := parseSeriesDesc(defLine)
|
||||
metric, vals, err := parser.ParseSeriesDesc(defLine)
|
||||
if err != nil {
|
||||
if perr, ok := err.(*parser.ParseErr); ok {
|
||||
perr.lineOffset = i
|
||||
perr.LineOffset = i
|
||||
}
|
||||
return i, nil, err
|
||||
}
|
||||
|
|
@ -151,8 +151,8 @@ func (t *Test) parseEval(lines []string, i int) (int, *evalCmd, error) {
|
|||
_, err := parser.ParseExpr(expr)
|
||||
if err != nil {
|
||||
if perr, ok := err.(*parser.ParseErr); ok {
|
||||
perr.lineOffset = i
|
||||
posOffset := Pos(strings.Index(lines[i], expr))
|
||||
perr.LineOffset = i
|
||||
posOffset := parser.Pos(strings.Index(lines[i], expr))
|
||||
perr.PositionRange.Start += posOffset
|
||||
perr.PositionRange.End += posOffset
|
||||
perr.Query = lines[i]
|
||||
|
|
@ -160,7 +160,7 @@ func (t *Test) parseEval(lines []string, i int) (int, *evalCmd, error) {
|
|||
return i, nil, err
|
||||
}
|
||||
|
||||
offset, err := model.parser.ParseDuration(at)
|
||||
offset, err := model.ParseDuration(at)
|
||||
if err != nil {
|
||||
return i, nil, raise(i, "invalid step definition %q: %s", parts[1], err)
|
||||
}
|
||||
|
|
@ -182,13 +182,13 @@ func (t *Test) parseEval(lines []string, i int) (int, *evalCmd, error) {
|
|||
break
|
||||
}
|
||||
if f, err := parseNumber(defLine); err == nil {
|
||||
cmd.expect(0, nil, parser.SequenceValue{value: f})
|
||||
cmd.expect(0, nil, parser.SequenceValue{Value: f})
|
||||
break
|
||||
}
|
||||
metric, vals, err := parseSeriesDesc(defLine)
|
||||
metric, vals, err := parser.ParseSeriesDesc(defLine)
|
||||
if err != nil {
|
||||
if perr, ok := err.(*parser.ParseErr); ok {
|
||||
perr.lineOffset = i
|
||||
perr.LineOffset = i
|
||||
}
|
||||
return i, nil, err
|
||||
}
|
||||
|
|
@ -282,10 +282,10 @@ func (cmd *loadCmd) set(m labels.Labels, vals ...parser.SequenceValue) {
|
|||
samples := make([]Point, 0, len(vals))
|
||||
ts := testStartTime
|
||||
for _, v := range vals {
|
||||
if !v.omitted {
|
||||
if !v.Omitted {
|
||||
samples = append(samples, Point{
|
||||
T: ts.UnixNano() / int64(time.Millisecond/time.Nanosecond),
|
||||
V: v.value,
|
||||
V: v.Value,
|
||||
})
|
||||
}
|
||||
ts = ts.Add(cmd.gap)
|
||||
|
|
@ -374,8 +374,8 @@ func (ev *evalCmd) compareResult(result parser.Value) error {
|
|||
if ev.ordered && exp.pos != pos+1 {
|
||||
return errors.Errorf("expected metric %s with %v at position %d but was at %d", v.Metric, exp.vals, exp.pos, pos+1)
|
||||
}
|
||||
if !almostEqual(exp.vals[0].value, v.V) {
|
||||
return errors.Errorf("expected %v for %s but got %v", exp.vals[0].value, v.Metric, v.V)
|
||||
if !almostEqual(exp.vals[0].Value, v.V) {
|
||||
return errors.Errorf("expected %v for %s but got %v", exp.vals[0].Value, v.Metric, v.V)
|
||||
}
|
||||
|
||||
seen[fp] = true
|
||||
|
|
@ -391,8 +391,8 @@ func (ev *evalCmd) compareResult(result parser.Value) error {
|
|||
}
|
||||
|
||||
case Scalar:
|
||||
if !almostEqual(ev.expected[0].vals[0].value, val.V) {
|
||||
return errors.Errorf("expected Scalar %v but got %v", val.V, ev.expected[0].vals[0].value)
|
||||
if !almostEqual(ev.expected[0].vals[0].Value, val.V) {
|
||||
return errors.Errorf("expected Scalar %v but got %v", val.V, ev.expected[0].vals[0].Value)
|
||||
}
|
||||
|
||||
default:
|
||||
|
|
@ -459,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.parser.Value)
|
||||
err = cmd.compareResult(res.Value)
|
||||
if err != nil {
|
||||
return errors.Wrapf(err, "error in %s %s", cmd, cmd.expr)
|
||||
}
|
||||
|
|
@ -479,7 +479,7 @@ func (t *Test) exec(tc testCommand) error {
|
|||
// Ordering isn't defined for range queries.
|
||||
return nil
|
||||
}
|
||||
mat := rangeRes.parser.Value.(Matrix)
|
||||
mat := rangeRes.Value.(Matrix)
|
||||
vec := make(Vector, 0, len(mat))
|
||||
for _, series := range mat {
|
||||
for _, point := range series.Points {
|
||||
|
|
@ -489,7 +489,7 @@ func (t *Test) exec(tc testCommand) error {
|
|||
}
|
||||
}
|
||||
}
|
||||
if _, ok := res.parser.Value.(Scalar); ok {
|
||||
if _, ok := res.Value.(Scalar); ok {
|
||||
err = cmd.compareResult(Scalar{V: vec[0].Point.V})
|
||||
} else {
|
||||
err = cmd.compareResult(vec)
|
||||
|
|
@ -559,10 +559,10 @@ func almostEqual(a, b float64) bool {
|
|||
}
|
||||
|
||||
func parseNumber(s string) (float64, error) {
|
||||
n, err := strconv.parser.ParseInt(s, 0, 64)
|
||||
n, err := strconv.ParseInt(s, 0, 64)
|
||||
f := float64(n)
|
||||
if err != nil {
|
||||
f, err = strconv.parser.ParseFloat(s, 64)
|
||||
f, err = strconv.ParseFloat(s, 64)
|
||||
}
|
||||
if err != nil {
|
||||
return 0, errors.Wrap(err, "error parsing number")
|
||||
|
|
|
|||
Loading…
Reference in a new issue