mudhorn/prometheus
1
0
Fork 0
mirror of https://github.com/prometheus/prometheus.git synced 2025-03-05 20:59:13 -08:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

Fix all build errors in promql package

Browse source 
Signed-off-by: Tobias Guggenmos <tguggenm@redhat.com>
This commit is contained in:
Tobias Guggenmos 2020-02-03 18:48:27 +01:00
parent 2164e366ea
commit 1360f9ff12
9 changed files with 256 additions and 256 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

144
promql/engine.go
View file

@ -1265,19 +1265,19 @@ func (ev *evaluator) eval(expr parser.Expr) parser.Value {
}, e.LHS, e.RHS) }, e.LHS, e.RHS)
} }
case *NumberLiteral: case *parser.NumberLiteral:
return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector { return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
return append(enh.out, Sample{Point: Point{V: e.Val}}) return append(enh.out, Sample{Point: Point{V: e.Val}})
}) })
case *parser.VectorSelector: case *parser.VectorSelector:
checkForSeriesSetExpansion(ev.ctx, e) checkForSeriesSetExpansion(ev.ctx, e)
mat := make(Matrix, 0, len(e.series)) mat := make(Matrix, 0, len(e.Series))
it := storage.NewBuffer(durationMilliseconds(ev.lookbackDelta)) it := storage.NewBuffer(durationMilliseconds(ev.lookbackDelta))
for i, s := range e.series { for i, s := range e.Series {
it.Reset(s.Iterator()) it.Reset(s.Iterator())
ss := Series{ ss := Series{
Metric: e.series[i].Labels(), Metric: e.Series[i].Labels(),
Points: getPointSlice(numSteps), Points: getPointSlice(numSteps),
} }
@ -1336,7 +1336,7 @@ func (ev *evaluator) eval(expr parser.Expr) parser.Value {
res := newEv.eval(e.Expr) res := newEv.eval(e.Expr)
ev.currentSamples = newEv.currentSamples ev.currentSamples = newEv.currentSamples
return res return res
case *StringLiteral: case *parser.StringLiteral:
return String{V: e.Val, T: ev.startTimestamp} 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) checkForSeriesSetExpansion(ev.ctx, node)
var ( var (
vec = make(Vector, 0, len(node.series)) vec = make(Vector, 0, len(node.Series))
) )
it := storage.NewBuffer(durationMilliseconds(ev.lookbackDelta)) it := storage.NewBuffer(durationMilliseconds(ev.lookbackDelta))
for i, s := range node.series { for i, s := range node.Series {
it.Reset(s.Iterator()) it.Reset(s.Iterator())
t, v, ok := ev.vectorSelectorSingle(it, node, ts) t, v, ok := ev.vectorSelectorSingle(it, node, ts)
if ok { if ok {
vec = append(vec, Sample{ vec = append(vec, Sample{
Metric: node.series[i].Labels(), Metric: node.Series[i].Labels(),
Point: Point{V: v, T: t}, Point: Point{V: v, T: t},
}) })
ev.currentSamples++ ev.currentSamples++
@ -1389,7 +1389,7 @@ func (ev *evaluator) vectorSelectorSingle(it *storage.BufferedSeriesIterator, no
} }
if ok { if ok {
t, v = it.parser.Values() t, v = it.Values()
} }
if !ok || t > refTime { if !ok || t > refTime {
@ -1429,11 +1429,11 @@ func (ev *evaluator) matrixSelector(node *parser.MatrixSelector) Matrix {
offset = durationMilliseconds(vs.Offset) offset = durationMilliseconds(vs.Offset)
maxt = ev.startTimestamp - offset maxt = ev.startTimestamp - offset
mint = maxt - durationMilliseconds(node.Range) 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)) it := storage.NewBuffer(durationMilliseconds(node.Range))
series := vs.series series := vs.Series
for i, s := range series { for i, s := range series {
if err := contextDone(ev.ctx, "expression evaluation"); err != nil { 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. // The seeked sample might also be in the range.
if ok { if ok {
t, v := it.parser.Values() t, v := it.Values()
if t == maxt && !value.IsStaleNaN(v) { if t == maxt && !value.IsStaleNaN(v) {
if ev.currentSamples >= ev.maxSamples { if ev.currentSamples >= ev.maxSamples {
ev.error(ErrTooManySamples(env)) 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 { 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") panic("set operations must only use many-to-many matching")
} }
sigf := enh.signatureFunc(matching.On, matching.MatchingLabels...) 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 { 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") panic("set operations must only use many-to-many matching")
} }
sigf := enh.signatureFunc(matching.On, matching.MatchingLabels...) 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 { 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") panic("set operations must only use many-to-many matching")
} }
sigf := enh.signatureFunc(matching.On, matching.MatchingLabels...) 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. // 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 { 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") panic("many-to-many only allowed for set operators")
} }
sigf := enh.signatureFunc(matching.On, matching.MatchingLabels...) 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. // 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 // For one-to-many, swap sidedness and account for the swap when calculating
// values. // values.
if matching.Card == CardOneToMany { if matching.Card == parser.CardOneToMany {
lhs, rhs = rhs, lhs 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 { if duplSample, found := rightSigs[sig]; found {
// oneSide represents which side of the vector represents the 'one' in the many-to-one relationship. // oneSide represents which side of the vector represents the 'one' in the many-to-one relationship.
oneSide := "right" oneSide := "right"
if matching.Card == CardOneToMany { if matching.Card == parser.CardOneToMany {
oneSide = "left" oneSide = "left"
} }
matchedLabels := rs.Metric.MatchLabels(matching.On, matching.MatchingLabels...) 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. // Account for potentially swapped sidedness.
vl, vr := ls.V, rs.V vl, vr := ls.V, rs.V
if matching.Card == CardOneToMany { if matching.Card == parser.CardOneToMany {
vl, vr = vr, vl vl, vr = vr, vl
} }
value, keep := vectorElemBinop(op, vl, vr) 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) metric := resultMetric(ls.Metric, rs.Metric, op, matching, enh)
insertedSigs, exists := matchedSigs[sig] insertedSigs, exists := matchedSigs[sig]
if matching.Card == CardOneToOne { if matching.Card == parser.CardOneToOne {
if exists { if exists {
ev.errorf("multiple matches for labels: many-to-one matching must be explicit (group_left/group_right)") 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) lb.Del(labels.MetricName)
} }
if matching.Card == CardOneToOne { if matching.Card == parser.CardOneToOne {
if matching.On { if matching.On {
Outer: Outer:
for _, l := range lhs { 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) value, keep := vectorElemBinop(op, lv, rv)
// Catch cases where the scalar is the LHS in a scalar-vector comparison operation. // 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. // 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 value = rv
} }
if returnBool { if returnBool {
@ -1797,29 +1797,29 @@ func dropMetricName(l labels.Labels) labels.Labels {
// scalarBinop evaluates a binary operation between two Scalars. // scalarBinop evaluates a binary operation between two Scalars.
func scalarBinop(op parser.ItemType, lhs, rhs float64) float64 { func scalarBinop(op parser.ItemType, lhs, rhs float64) float64 {
switch op { switch op {
case ADD: case parser.ADD:
return lhs + rhs return lhs + rhs
case SUB: case parser.SUB:
return lhs - rhs return lhs - rhs
case MUL: case parser.MUL:
return lhs * rhs return lhs * rhs
case DIV: case parser.DIV:
return lhs / rhs return lhs / rhs
case POW: case parser.POW:
return math.Pow(lhs, rhs) return math.Pow(lhs, rhs)
case MOD: case parser.MOD:
return math.Mod(lhs, rhs) return math.Mod(lhs, rhs)
case EQL: case parser.EQL:
return btos(lhs == rhs) return btos(lhs == rhs)
case NEQ: case parser.NEQ:
return btos(lhs != rhs) return btos(lhs != rhs)
case GTR: case parser.GTR:
return btos(lhs > rhs) return btos(lhs > rhs)
case LSS: case parser.LSS:
return btos(lhs < rhs) return btos(lhs < rhs)
case GTE: case parser.GTE:
return btos(lhs >= rhs) return btos(lhs >= rhs)
case LTE: case parser.LTE:
return btos(lhs <= rhs) return btos(lhs <= rhs)
} }
panic(errors.Errorf("operator %q not allowed for Scalar operations", op)) 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. // vectorElemBinop evaluates a binary operation between two Vector elements.
func vectorElemBinop(op parser.ItemType, lhs, rhs float64) (float64, bool) { func vectorElemBinop(op parser.ItemType, lhs, rhs float64) (float64, bool) {
switch op { switch op {
case ADD: case parser.ADD:
return lhs + rhs, true return lhs + rhs, true
case SUB: case parser.SUB:
return lhs - rhs, true return lhs - rhs, true
case MUL: case parser.MUL:
return lhs * rhs, true return lhs * rhs, true
case DIV: case parser.DIV:
return lhs / rhs, true return lhs / rhs, true
case POW: case parser.POW:
return math.Pow(lhs, rhs), true return math.Pow(lhs, rhs), true
case MOD: case parser.MOD:
return math.Mod(lhs, rhs), true return math.Mod(lhs, rhs), true
case EQL: case parser.EQL:
return lhs, lhs == rhs return lhs, lhs == rhs
case NEQ: case parser.NEQ:
return lhs, lhs != rhs return lhs, lhs != rhs
case GTR: case parser.GTR:
return lhs, lhs > rhs return lhs, lhs > rhs
case LSS: case parser.LSS:
return lhs, lhs < rhs return lhs, lhs < rhs
case GTE: case parser.GTE:
return lhs, lhs >= rhs return lhs, lhs >= rhs
case LTE: case parser.LTE:
return lhs, lhs <= rhs return lhs, lhs <= rhs
} }
panic(errors.Errorf("operator %q not allowed for operations between Vectors", op)) 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{} result := map[uint64]*groupedAggregation{}
var k int64 var k int64
if op == TOPK || op == BOTTOMK { if op == parser.TOPK || op == parser.BOTTOMK {
f := param.(float64) f := param.(float64)
if !convertibleToInt64(f) { if !convertibleToInt64(f) {
ev.errorf("Scalar value %v overflows int64", 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 var q float64
if op == QUANTILE { if op == parser.QUANTILE {
q = param.(float64) q = param.(float64)
} }
var valueLabel string var valueLabel string
if op == COUNT_VALUES { if op == parser.COUNT_VALUES {
valueLabel = param.(string) valueLabel = param.(string)
if !model.LabelName(valueLabel).IsValid() { if !model.LabelName(valueLabel).IsValid() {
ev.errorf("invalid label name %q", valueLabel) 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 { for _, s := range vec {
metric := s.Metric metric := s.Metric
if op == COUNT_VALUES { if op == parser.COUNT_VALUES {
lb.Reset(metric) lb.Reset(metric)
lb.Set(valueLabel, strconv.FormatFloat(s.V, 'f', -1, 64)) lb.Set(valueLabel, strconv.FormatFloat(s.V, 'f', -1, 64))
metric = lb.Labels() metric = lb.Labels()
@ -1949,15 +1949,15 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
if k > inputVecLen { if k > inputVecLen {
resultSize = inputVecLen resultSize = inputVecLen
} }
if op == STDVAR || op == STDDEV { if op == parser.STDVAR || op == parser.STDDEV {
result[groupingKey].value = 0.0 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) result[groupingKey].heap = make(vectorByValueHeap, 0, resultSize)
heap.Push(&result[groupingKey].heap, &Sample{ heap.Push(&result[groupingKey].heap, &Sample{
Point: Point{V: s.V}, Point: Point{V: s.V},
Metric: s.Metric, Metric: s.Metric,
}) })
} else if op == BOTTOMK { } else if op == parser.BOTTOMK {
result[groupingKey].reverseHeap = make(vectorByReverseValueHeap, 0, resultSize) result[groupingKey].reverseHeap = make(vectorByReverseValueHeap, 0, resultSize)
heap.Push(&result[groupingKey].reverseHeap, &Sample{ heap.Push(&result[groupingKey].reverseHeap, &Sample{
Point: Point{V: s.V}, Point: Point{V: s.V},
@ -1968,33 +1968,33 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
} }
switch op { switch op {
case SUM: case parser.SUM:
group.value += s.V group.value += s.V
case AVG: case parser.AVG:
group.groupCount++ group.groupCount++
group.mean += (s.V - group.mean) / float64(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) { if group.value < s.V || math.IsNaN(group.value) {
group.value = s.V group.value = s.V
} }
case MIN: case parser.MIN:
if group.value > s.V || math.IsNaN(group.value) { if group.value > s.V || math.IsNaN(group.value) {
group.value = s.V group.value = s.V
} }
case COUNT, COUNT_VALUES: case parser.COUNT, parser.COUNT_VALUES:
group.groupCount++ group.groupCount++
case STDVAR, STDDEV: case parser.STDVAR, parser.STDDEV:
group.groupCount++ group.groupCount++
delta := s.V - group.mean delta := s.V - group.mean
group.mean += delta / float64(group.groupCount) group.mean += delta / float64(group.groupCount)
group.value += delta * (s.V - group.mean) 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 || group.heap[0].V < s.V || math.IsNaN(group.heap[0].V) {
if int64(len(group.heap)) == k { if int64(len(group.heap)) == k {
heap.Pop(&group.heap) 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 || group.reverseHeap[0].V > s.V || math.IsNaN(group.reverseHeap[0].V) {
if int64(len(group.reverseHeap)) == k { if int64(len(group.reverseHeap)) == k {
heap.Pop(&group.reverseHeap) 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) group.heap = append(group.heap, s)
default: default:
@ -2027,19 +2027,19 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
// Construct the result Vector from the aggregated groups. // Construct the result Vector from the aggregated groups.
for _, aggr := range result { for _, aggr := range result {
switch op { switch op {
case AVG: case parser.AVG:
aggr.value = aggr.mean aggr.value = aggr.mean
case COUNT, COUNT_VALUES: case parser.COUNT, parser.COUNT_VALUES:
aggr.value = float64(aggr.groupCount) aggr.value = float64(aggr.groupCount)
case STDVAR: case parser.STDVAR:
aggr.value = aggr.value / float64(aggr.groupCount) aggr.value = aggr.value / float64(aggr.groupCount)
case STDDEV: case parser.STDDEV:
aggr.value = math.Sqrt(aggr.value / float64(aggr.groupCount)) 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. // The heap keeps the lowest value on top, so reverse it.
sort.Sort(sort.Reverse(aggr.heap)) sort.Sort(sort.Reverse(aggr.heap))
for _, v := range 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. continue // Bypass default append.
case BOTTOMK: case parser.BOTTOMK:
// The heap keeps the lowest value on top, so reverse it. // The heap keeps the lowest value on top, so reverse it.
sort.Sort(sort.Reverse(aggr.reverseHeap)) sort.Sort(sort.Reverse(aggr.reverseHeap))
for _, v := range 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. continue // Bypass default append.
case QUANTILE: case parser.QUANTILE:
aggr.value = quantile(q, aggr.heap) aggr.value = quantile(q, aggr.heap)
default: default:
@ -2088,7 +2088,7 @@ func btos(b bool) float64 {
// result of the op operation. // result of the op operation.
func shouldDropMetricName(op parser.ItemType) bool { func shouldDropMetricName(op parser.ItemType) bool {
switch op { switch op {
case ADD, SUB, DIV, MUL, POW, MOD: case parser.ADD, parser.SUB, parser.DIV, parser.MUL, parser.POW, parser.MOD:
return true return true
default: default:
return false return false
@ -2107,8 +2107,8 @@ func formatDate(t time.Time) string {
// unwrapParenExpr does the AST equivalent of removing parentheses around a expression. // unwrapParenExpr does the AST equivalent of removing parentheses around a expression.
func unwrapParenExpr(e *parser.Expr) { func unwrapParenExpr(e *parser.Expr) {
for { for {
if p, ok := (*e).(*ParenExpr); ok { if p, ok := (*e).(*parser.ParenExpr); ok {
*e = p.parser.Expr *e = p.Expr
} else { } else {
break break
} }

22
promql/functions.go
View file

@ -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. // 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 { func extrapolatedRate(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelper, isCounter bool, isRate bool) Vector {
ms := args[0].(*parser.MatrixSelector) ms := args[0].(*parser.MatrixSelector)
vs := ms.parser.VectorSelector.(*parser.VectorSelector) vs := ms.VectorSelector.(*parser.VectorSelector)
var ( var (
samples = vals[0].(Matrix)[0] 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 { func funcLabelReplace(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelper) Vector {
var ( var (
vector = vals[0].(Vector) vector = vals[0].(Vector)
dst = args[1].(*StringLiteral).Val dst = args[1].(*parser.StringLiteral).Val
repl = args[2].(*StringLiteral).Val repl = args[2].(*parser.StringLiteral).Val
src = args[3].(*StringLiteral).Val src = args[3].(*parser.StringLiteral).Val
regexStr = args[4].(*StringLiteral).Val regexStr = args[4].(*parser.StringLiteral).Val
) )
if enh.regex == nil { 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 { func funcLabelJoin(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelper) Vector {
var ( var (
vector = vals[0].(Vector) vector = vals[0].(Vector)
dst = args[1].(*StringLiteral).Val dst = args[1].(*parser.StringLiteral).Val
sep = args[2].(*StringLiteral).Val sep = args[2].(*parser.StringLiteral).Val
srcLabels = make([]string, len(args)-3) 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++ { for i := 3; i < len(args); i++ {
src := args[i].(*StringLiteral).Val src := args[i].(*parser.StringLiteral).Val
if !model.LabelName(src).IsValid() { if !model.LabelName(src).IsValid() {
panic(errors.Errorf("invalid source label name in label_join(): %s", src)) panic(errors.Errorf("invalid source label name in label_join(): %s", src))
} }
@ -889,7 +889,7 @@ var FunctionCalls = map[string]FunctionCall{
"floor": funcFloor, "floor": funcFloor,
"histogram_quantile": funcHistogramQuantile, "histogram_quantile": funcHistogramQuantile,
"holt_winters": funcHoltWinters, "holt_winters": funcHoltWinters,
"hour": parser.ValueTypeVector, "hour": funcHour,
"idelta": funcIdelta, "idelta": funcIdelta,
"increase": funcIncrease, "increase": funcIncrease,
"irate": funcIrate, "irate": funcIrate,
@ -994,7 +994,7 @@ func createLabelsForAbsentFunction(expr parser.Expr) labels.Labels {
case *parser.VectorSelector: case *parser.VectorSelector:
lm = n.LabelMatchers lm = n.LabelMatchers
case *parser.MatrixSelector: case *parser.MatrixSelector:
lm = n.parser.VectorSelector.(*parser.VectorSelector).LabelMatchers lm = n.VectorSelector.(*parser.VectorSelector).LabelMatchers
default: default:
return m return m
} }
@ -1005,7 +1005,7 @@ func createLabelsForAbsentFunction(expr parser.Expr) labels.Labels {
continue continue
} }
if ma.Type == labels.MatchEqual && !m.Has(ma.Name) { 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 { } else {
empty = append(empty, ma.Name) empty = append(empty, ma.Name)
} }

20
promql/parser/generated_parser.y
View file

@ -33,7 +33,7 @@ import (
label labels.Label label labels.Label
labels labels.Labels labels labels.Labels
strings []string strings []string
series []sequenceValue series []SequenceValue
uint uint64 uint uint64
float float64 float float64
duration time.Duration duration time.Duration
@ -577,7 +577,7 @@ series_description: metric series_values
; ;
series_values : /*empty*/ series_values : /*empty*/
{ $$ = []sequenceValue{} } { $$ = []SequenceValue{} }
| series_values SPACE series_item | series_values SPACE series_item
{ $$ = append($1, $3...) } { $$ = append($1, $3...) }
| series_values SPACE | series_values SPACE
@ -587,28 +587,28 @@ series_values : /*empty*/
; ;
series_item : BLANK series_item : BLANK
{ $$ = []sequenceValue{{omitted: true}}} { $$ = []SequenceValue{{Omitted: true}}}
| BLANK TIMES uint | BLANK TIMES uint
{ {
$$ = []sequenceValue{} $$ = []SequenceValue{}
for i:=uint64(0); i < $3; i++{ for i:=uint64(0); i < $3; i++{
$$ = append($$, sequenceValue{omitted: true}) $$ = append($$, SequenceValue{Omitted: true})
} }
} }
| series_value | series_value
{ $$ = []sequenceValue{{value: $1}}} { $$ = []SequenceValue{{Value: $1}}}
| series_value TIMES uint | series_value TIMES uint
{ {
$$ = []sequenceValue{} $$ = []SequenceValue{}
for i:=uint64(0); i <= $3; i++{ for i:=uint64(0); i <= $3; i++{
$$ = append($$, sequenceValue{value: $1}) $$ = append($$, SequenceValue{Value: $1})
} }
} }
| series_value signed_number TIMES uint | series_value signed_number TIMES uint
{ {
$$ = []sequenceValue{} $$ = []SequenceValue{}
for i:=uint64(0); i <= $4; i++{ for i:=uint64(0); i <= $4; i++{
$$ = append($$, sequenceValue{value: $1}) $$ = append($$, SequenceValue{Value: $1})
$1 += $2 $1 += $2
} }
} }

226
promql/parser/generated_parser.y.go
View file

@ -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 package parser
import __yyfmt__ "fmt" import __yyfmt__ "fmt"
//line promql/generated_parser.y:15 //line generated_parser.y:15
import ( import (
"math" "math"
@ -17,7 +17,7 @@ import (
"github.com/prometheus/prometheus/pkg/value" "github.com/prometheus/prometheus/pkg/value"
) )
//line promql/generated_parser.y:28 //line generated_parser.y:28
type yySymType struct { type yySymType struct {
yys int yys int
node Node node Node
@ -183,7 +183,7 @@ const yyEofCode = 1
const yyErrCode = 2 const yyErrCode = 2
const yyInitialStackSize = 16 const yyInitialStackSize = 16
//line promql/generated_parser.y:706 //line generated_parser.y:706
//line yacctab:1 //line yacctab:1
var yyExca = [...]int{ var yyExca = [...]int{
@ -786,62 +786,62 @@ yydefault:
case 1: case 1:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:164 //line generated_parser.y:164
{ {
yylex.(*parser).generatedParserResult = yyDollar[2].labels yylex.(*parser).generatedParserResult = yyDollar[2].labels
} }
case 3: case 3:
yyDollar = yyS[yypt-2 : yypt+1] 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") yylex.(*parser).addParseErrf(PositionRange{}, "no expression found in input")
} }
case 4: case 4:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:169 //line generated_parser.y:169
{ {
yylex.(*parser).generatedParserResult = yyDollar[2].node yylex.(*parser).generatedParserResult = yyDollar[2].node
} }
case 5: case 5:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:171 //line generated_parser.y:171
{ {
yylex.(*parser).generatedParserResult = yyDollar[2].node yylex.(*parser).generatedParserResult = yyDollar[2].node
} }
case 7: case 7:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:174 //line generated_parser.y:174
{ {
yylex.(*parser).unexpected("", "") yylex.(*parser).unexpected("", "")
} }
case 19: case 19:
yyDollar = yyS[yypt-3 : yypt+1] 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) yyVAL.node = yylex.(*parser).newAggregateExpr(yyDollar[1].item, yyDollar[2].node, yyDollar[3].node)
} }
case 20: case 20:
yyDollar = yyS[yypt-3 : yypt+1] 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) yyVAL.node = yylex.(*parser).newAggregateExpr(yyDollar[1].item, yyDollar[3].node, yyDollar[2].node)
} }
case 21: case 21:
yyDollar = yyS[yypt-2 : yypt+1] 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) yyVAL.node = yylex.(*parser).newAggregateExpr(yyDollar[1].item, &AggregateExpr{}, yyDollar[2].node)
} }
case 22: case 22:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:202 //line generated_parser.y:202
{ {
yylex.(*parser).unexpected("aggregation", "") yylex.(*parser).unexpected("aggregation", "")
yyVAL.node = nil yyVAL.node = nil
} }
case 23: case 23:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:207 //line generated_parser.y:207
{ {
yyVAL.node = &AggregateExpr{ yyVAL.node = &AggregateExpr{
Grouping: yyDollar[2].strings, Grouping: yyDollar[2].strings,
@ -849,7 +849,7 @@ yydefault:
} }
case 24: case 24:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:213 //line generated_parser.y:213
{ {
yyVAL.node = &AggregateExpr{ yyVAL.node = &AggregateExpr{
Grouping: yyDollar[2].strings, Grouping: yyDollar[2].strings,
@ -858,97 +858,97 @@ yydefault:
} }
case 25: case 25:
yyDollar = yyS[yypt-4 : yypt+1] 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) yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
} }
case 26: case 26:
yyDollar = yyS[yypt-4 : yypt+1] 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) yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
} }
case 27: case 27:
yyDollar = yyS[yypt-4 : yypt+1] 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) yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
} }
case 28: case 28:
yyDollar = yyS[yypt-4 : yypt+1] 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) yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
} }
case 29: case 29:
yyDollar = yyS[yypt-4 : yypt+1] 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) yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
} }
case 30: case 30:
yyDollar = yyS[yypt-4 : yypt+1] 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) yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
} }
case 31: case 31:
yyDollar = yyS[yypt-4 : yypt+1] 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) yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
} }
case 32: case 32:
yyDollar = yyS[yypt-4 : yypt+1] 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) yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
} }
case 33: case 33:
yyDollar = yyS[yypt-4 : yypt+1] 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) yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
} }
case 34: case 34:
yyDollar = yyS[yypt-4 : yypt+1] 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) yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
} }
case 35: case 35:
yyDollar = yyS[yypt-4 : yypt+1] 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) yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
} }
case 36: case 36:
yyDollar = yyS[yypt-4 : yypt+1] 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) yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
} }
case 37: case 37:
yyDollar = yyS[yypt-4 : yypt+1] 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) yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
} }
case 38: case 38:
yyDollar = yyS[yypt-4 : yypt+1] 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) yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
} }
case 39: case 39:
yyDollar = yyS[yypt-4 : yypt+1] 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) yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
} }
case 41: case 41:
yyDollar = yyS[yypt-0 : yypt+1] yyDollar = yyS[yypt-0 : yypt+1]
//line promql/generated_parser.y:248 //line generated_parser.y:248
{ {
yyVAL.node = &BinaryExpr{ yyVAL.node = &BinaryExpr{
VectorMatching: &VectorMatching{Card: CardOneToOne}, VectorMatching: &VectorMatching{Card: CardOneToOne},
@ -956,7 +956,7 @@ yydefault:
} }
case 42: case 42:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:253 //line generated_parser.y:253
{ {
yyVAL.node = &BinaryExpr{ yyVAL.node = &BinaryExpr{
VectorMatching: &VectorMatching{Card: CardOneToOne}, VectorMatching: &VectorMatching{Card: CardOneToOne},
@ -965,14 +965,14 @@ yydefault:
} }
case 43: case 43:
yyDollar = yyS[yypt-3 : yypt+1] yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:261 //line generated_parser.y:261
{ {
yyVAL.node = yyDollar[1].node yyVAL.node = yyDollar[1].node
yyVAL.node.(*BinaryExpr).VectorMatching.MatchingLabels = yyDollar[3].strings yyVAL.node.(*BinaryExpr).VectorMatching.MatchingLabels = yyDollar[3].strings
} }
case 44: case 44:
yyDollar = yyS[yypt-3 : yypt+1] yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:266 //line generated_parser.y:266
{ {
yyVAL.node = yyDollar[1].node yyVAL.node = yyDollar[1].node
yyVAL.node.(*BinaryExpr).VectorMatching.MatchingLabels = yyDollar[3].strings yyVAL.node.(*BinaryExpr).VectorMatching.MatchingLabels = yyDollar[3].strings
@ -980,7 +980,7 @@ yydefault:
} }
case 47: case 47:
yyDollar = yyS[yypt-3 : yypt+1] yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:276 //line generated_parser.y:276
{ {
yyVAL.node = yyDollar[1].node yyVAL.node = yyDollar[1].node
yyVAL.node.(*BinaryExpr).VectorMatching.Card = CardManyToOne yyVAL.node.(*BinaryExpr).VectorMatching.Card = CardManyToOne
@ -988,7 +988,7 @@ yydefault:
} }
case 48: case 48:
yyDollar = yyS[yypt-3 : yypt+1] yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:282 //line generated_parser.y:282
{ {
yyVAL.node = yyDollar[1].node yyVAL.node = yyDollar[1].node
yyVAL.node.(*BinaryExpr).VectorMatching.Card = CardOneToMany yyVAL.node.(*BinaryExpr).VectorMatching.Card = CardOneToMany
@ -996,51 +996,51 @@ yydefault:
} }
case 49: case 49:
yyDollar = yyS[yypt-3 : yypt+1] yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:291 //line generated_parser.y:291
{ {
yyVAL.strings = yyDollar[2].strings yyVAL.strings = yyDollar[2].strings
} }
case 50: case 50:
yyDollar = yyS[yypt-4 : yypt+1] yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:293 //line generated_parser.y:293
{ {
yyVAL.strings = yyDollar[2].strings yyVAL.strings = yyDollar[2].strings
} }
case 51: case 51:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:295 //line generated_parser.y:295
{ {
yyVAL.strings = []string{} yyVAL.strings = []string{}
} }
case 52: case 52:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:297 //line generated_parser.y:297
{ {
yylex.(*parser).unexpected("grouping opts", "\"(\"") yylex.(*parser).unexpected("grouping opts", "\"(\"")
yyVAL.strings = nil yyVAL.strings = nil
} }
case 53: case 53:
yyDollar = yyS[yypt-3 : yypt+1] 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) yyVAL.strings = append(yyDollar[1].strings, yyDollar[3].item.Val)
} }
case 54: case 54:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:305 //line generated_parser.y:305
{ {
yyVAL.strings = []string{yyDollar[1].item.Val} yyVAL.strings = []string{yyDollar[1].item.Val}
} }
case 55: case 55:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:307 //line generated_parser.y:307
{ {
yylex.(*parser).unexpected("grouping opts", "\",\" or \")\"") yylex.(*parser).unexpected("grouping opts", "\",\" or \")\"")
yyVAL.strings = yyDollar[1].strings yyVAL.strings = yyDollar[1].strings
} }
case 56: case 56:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:311 //line generated_parser.y:311
{ {
if !isLabel(yyDollar[1].item.Val) { if !isLabel(yyDollar[1].item.Val) {
yylex.(*parser).unexpected("grouping opts", "label") yylex.(*parser).unexpected("grouping opts", "label")
@ -1049,14 +1049,14 @@ yydefault:
} }
case 57: case 57:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:318 //line generated_parser.y:318
{ {
yylex.(*parser).unexpected("grouping opts", "label") yylex.(*parser).unexpected("grouping opts", "label")
yyVAL.item = Item{} yyVAL.item = Item{}
} }
case 58: case 58:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:326 //line generated_parser.y:326
{ {
fn, exist := getFunction(yyDollar[1].item.Val) fn, exist := getFunction(yyDollar[1].item.Val)
if !exist { if !exist {
@ -1073,58 +1073,58 @@ yydefault:
} }
case 59: case 59:
yyDollar = yyS[yypt-3 : yypt+1] yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:343 //line generated_parser.y:343
{ {
yyVAL.node = yyDollar[2].node yyVAL.node = yyDollar[2].node
} }
case 60: case 60:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:345 //line generated_parser.y:345
{ {
yyVAL.node = Expressions{} yyVAL.node = Expressions{}
} }
case 61: case 61:
yyDollar = yyS[yypt-3 : yypt+1] 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)) yyVAL.node = append(yyDollar[1].node.(Expressions), yyDollar[3].node.(Expr))
} }
case 62: case 62:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:351 //line generated_parser.y:351
{ {
yyVAL.node = Expressions{yyDollar[1].node.(Expr)} yyVAL.node = Expressions{yyDollar[1].node.(Expr)}
} }
case 63: case 63:
yyDollar = yyS[yypt-2 : yypt+1] 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") yylex.(*parser).addParseErrf(yyDollar[2].item.PositionRange(), "trailing commas not allowed in function call args")
yyVAL.node = yyDollar[1].node yyVAL.node = yyDollar[1].node
} }
case 64: case 64:
yyDollar = yyS[yypt-3 : yypt+1] 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)} yyVAL.node = &ParenExpr{Expr: yyDollar[2].node.(Expr), PosRange: mergeRanges(&yyDollar[1].item, &yyDollar[3].item)}
} }
case 65: case 65:
yyDollar = yyS[yypt-3 : yypt+1] 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) yylex.(*parser).addOffset(yyDollar[1].node, yyDollar[3].duration)
yyVAL.node = yyDollar[1].node yyVAL.node = yyDollar[1].node
} }
case 66: case 66:
yyDollar = yyS[yypt-3 : yypt+1] yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:377 //line generated_parser.y:377
{ {
yylex.(*parser).unexpected("offset", "duration") yylex.(*parser).unexpected("offset", "duration")
yyVAL.node = yyDollar[1].node yyVAL.node = yyDollar[1].node
} }
case 67: case 67:
yyDollar = yyS[yypt-4 : yypt+1] yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:385 //line generated_parser.y:385
{ {
var errMsg string var errMsg string
vs, ok := yyDollar[1].node.(*VectorSelector) vs, ok := yyDollar[1].node.(*VectorSelector)
@ -1147,7 +1147,7 @@ yydefault:
} }
case 68: case 68:
yyDollar = yyS[yypt-6 : yypt+1] yyDollar = yyS[yypt-6 : yypt+1]
//line promql/generated_parser.y:408 //line generated_parser.y:408
{ {
yyVAL.node = &SubqueryExpr{ yyVAL.node = &SubqueryExpr{
Expr: yyDollar[1].node.(Expr), Expr: yyDollar[1].node.(Expr),
@ -1159,35 +1159,35 @@ yydefault:
} }
case 69: case 69:
yyDollar = yyS[yypt-6 : yypt+1] yyDollar = yyS[yypt-6 : yypt+1]
//line promql/generated_parser.y:418 //line generated_parser.y:418
{ {
yylex.(*parser).unexpected("subquery selector", "\"]\"") yylex.(*parser).unexpected("subquery selector", "\"]\"")
yyVAL.node = yyDollar[1].node yyVAL.node = yyDollar[1].node
} }
case 70: case 70:
yyDollar = yyS[yypt-5 : yypt+1] yyDollar = yyS[yypt-5 : yypt+1]
//line promql/generated_parser.y:420 //line generated_parser.y:420
{ {
yylex.(*parser).unexpected("subquery selector", "duration or \"]\"") yylex.(*parser).unexpected("subquery selector", "duration or \"]\"")
yyVAL.node = yyDollar[1].node yyVAL.node = yyDollar[1].node
} }
case 71: case 71:
yyDollar = yyS[yypt-4 : yypt+1] yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:422 //line generated_parser.y:422
{ {
yylex.(*parser).unexpected("subquery or range", "\":\" or \"]\"") yylex.(*parser).unexpected("subquery or range", "\":\" or \"]\"")
yyVAL.node = yyDollar[1].node yyVAL.node = yyDollar[1].node
} }
case 72: case 72:
yyDollar = yyS[yypt-3 : yypt+1] yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:424 //line generated_parser.y:424
{ {
yylex.(*parser).unexpected("subquery selector", "duration") yylex.(*parser).unexpected("subquery selector", "duration")
yyVAL.node = yyDollar[1].node yyVAL.node = yyDollar[1].node
} }
case 73: case 73:
yyDollar = yyS[yypt-2 : yypt+1] 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 nl, ok := yyDollar[2].node.(*NumberLiteral); ok {
if yyDollar[1].item.Typ == SUB { if yyDollar[1].item.Typ == SUB {
@ -1201,7 +1201,7 @@ yydefault:
} }
case 74: case 74:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:452 //line generated_parser.y:452
{ {
vs := yyDollar[2].node.(*VectorSelector) vs := yyDollar[2].node.(*VectorSelector)
vs.PosRange = mergeRanges(&yyDollar[1].item, vs) vs.PosRange = mergeRanges(&yyDollar[1].item, vs)
@ -1211,7 +1211,7 @@ yydefault:
} }
case 75: case 75:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:460 //line generated_parser.y:460
{ {
vs := &VectorSelector{ vs := &VectorSelector{
Name: yyDollar[1].item.Val, Name: yyDollar[1].item.Val,
@ -1223,7 +1223,7 @@ yydefault:
} }
case 76: case 76:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:470 //line generated_parser.y:470
{ {
vs := yyDollar[1].node.(*VectorSelector) vs := yyDollar[1].node.(*VectorSelector)
yylex.(*parser).assembleVectorSelector(vs) yylex.(*parser).assembleVectorSelector(vs)
@ -1231,7 +1231,7 @@ yydefault:
} }
case 77: case 77:
yyDollar = yyS[yypt-3 : yypt+1] yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:478 //line generated_parser.y:478
{ {
yyVAL.node = &VectorSelector{ yyVAL.node = &VectorSelector{
LabelMatchers: yyDollar[2].matchers, LabelMatchers: yyDollar[2].matchers,
@ -1240,7 +1240,7 @@ yydefault:
} }
case 78: case 78:
yyDollar = yyS[yypt-4 : yypt+1] yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:485 //line generated_parser.y:485
{ {
yyVAL.node = &VectorSelector{ yyVAL.node = &VectorSelector{
LabelMatchers: yyDollar[2].matchers, LabelMatchers: yyDollar[2].matchers,
@ -1249,7 +1249,7 @@ yydefault:
} }
case 79: case 79:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:492 //line generated_parser.y:492
{ {
yyVAL.node = &VectorSelector{ yyVAL.node = &VectorSelector{
LabelMatchers: []*labels.Matcher{}, LabelMatchers: []*labels.Matcher{},
@ -1258,7 +1258,7 @@ yydefault:
} }
case 80: case 80:
yyDollar = yyS[yypt-3 : yypt+1] yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:501 //line generated_parser.y:501
{ {
if yyDollar[1].matchers != nil { if yyDollar[1].matchers != nil {
yyVAL.matchers = append(yyDollar[1].matchers, yyDollar[3].matcher) yyVAL.matchers = append(yyDollar[1].matchers, yyDollar[3].matcher)
@ -1268,130 +1268,130 @@ yydefault:
} }
case 81: case 81:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:509 //line generated_parser.y:509
{ {
yyVAL.matchers = []*labels.Matcher{yyDollar[1].matcher} yyVAL.matchers = []*labels.Matcher{yyDollar[1].matcher}
} }
case 82: case 82:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:511 //line generated_parser.y:511
{ {
yylex.(*parser).unexpected("label matching", "\",\" or \"}\"") yylex.(*parser).unexpected("label matching", "\",\" or \"}\"")
yyVAL.matchers = yyDollar[1].matchers yyVAL.matchers = yyDollar[1].matchers
} }
case 83: case 83:
yyDollar = yyS[yypt-3 : yypt+1] 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) yyVAL.matcher = yylex.(*parser).newLabelMatcher(yyDollar[1].item, yyDollar[2].item, yyDollar[3].item)
} }
case 84: case 84:
yyDollar = yyS[yypt-3 : yypt+1] yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:517 //line generated_parser.y:517
{ {
yylex.(*parser).unexpected("label matching", "string") yylex.(*parser).unexpected("label matching", "string")
yyVAL.matcher = nil yyVAL.matcher = nil
} }
case 85: case 85:
yyDollar = yyS[yypt-2 : yypt+1] 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") yylex.(*parser).unexpected("label matching", "label matching operator")
yyVAL.matcher = nil yyVAL.matcher = nil
} }
case 86: case 86:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:521 //line generated_parser.y:521
{ {
yylex.(*parser).unexpected("label matching", "identifier or \"}\"") yylex.(*parser).unexpected("label matching", "identifier or \"}\"")
yyVAL.matcher = nil yyVAL.matcher = nil
} }
case 87: case 87:
yyDollar = yyS[yypt-2 : yypt+1] 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}) yyVAL.labels = append(yyDollar[2].labels, labels.Label{Name: labels.MetricName, Value: yyDollar[1].item.Val})
sort.Sort(yyVAL.labels) sort.Sort(yyVAL.labels)
} }
case 88: case 88:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:531 //line generated_parser.y:531
{ {
yyVAL.labels = yyDollar[1].labels yyVAL.labels = yyDollar[1].labels
} }
case 91: case 91:
yyDollar = yyS[yypt-3 : yypt+1] yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:538 //line generated_parser.y:538
{ {
yyVAL.labels = labels.New(yyDollar[2].labels...) yyVAL.labels = labels.New(yyDollar[2].labels...)
} }
case 92: case 92:
yyDollar = yyS[yypt-4 : yypt+1] yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:540 //line generated_parser.y:540
{ {
yyVAL.labels = labels.New(yyDollar[2].labels...) yyVAL.labels = labels.New(yyDollar[2].labels...)
} }
case 93: case 93:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:542 //line generated_parser.y:542
{ {
yyVAL.labels = labels.New() yyVAL.labels = labels.New()
} }
case 94: case 94:
yyDollar = yyS[yypt-0 : yypt+1] yyDollar = yyS[yypt-0 : yypt+1]
//line promql/generated_parser.y:544 //line generated_parser.y:544
{ {
yyVAL.labels = labels.New() yyVAL.labels = labels.New()
} }
case 95: case 95:
yyDollar = yyS[yypt-3 : yypt+1] 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) yyVAL.labels = append(yyDollar[1].labels, yyDollar[3].label)
} }
case 96: case 96:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:550 //line generated_parser.y:550
{ {
yyVAL.labels = []labels.Label{yyDollar[1].label} yyVAL.labels = []labels.Label{yyDollar[1].label}
} }
case 97: case 97:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:552 //line generated_parser.y:552
{ {
yylex.(*parser).unexpected("label set", "\",\" or \"}\"") yylex.(*parser).unexpected("label set", "\",\" or \"}\"")
yyVAL.labels = yyDollar[1].labels yyVAL.labels = yyDollar[1].labels
} }
case 98: case 98:
yyDollar = yyS[yypt-3 : yypt+1] 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)} yyVAL.label = labels.Label{Name: yyDollar[1].item.Val, Value: yylex.(*parser).unquoteString(yyDollar[3].item.Val)}
} }
case 99: case 99:
yyDollar = yyS[yypt-3 : yypt+1] yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:559 //line generated_parser.y:559
{ {
yylex.(*parser).unexpected("label set", "string") yylex.(*parser).unexpected("label set", "string")
yyVAL.label = labels.Label{} yyVAL.label = labels.Label{}
} }
case 100: case 100:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:561 //line generated_parser.y:561
{ {
yylex.(*parser).unexpected("label set", "\"=\"") yylex.(*parser).unexpected("label set", "\"=\"")
yyVAL.label = labels.Label{} yyVAL.label = labels.Label{}
} }
case 101: case 101:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:563 //line generated_parser.y:563
{ {
yylex.(*parser).unexpected("label set", "identifier or \"}\"") yylex.(*parser).unexpected("label set", "identifier or \"}\"")
yyVAL.label = labels.Label{} yyVAL.label = labels.Label{}
} }
case 102: case 102:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:571 //line generated_parser.y:571
{ {
yylex.(*parser).generatedParserResult = &seriesDescription{ yylex.(*parser).generatedParserResult = &seriesDescription{
labels: yyDollar[1].labels, labels: yyDollar[1].labels,
@ -1400,72 +1400,72 @@ yydefault:
} }
case 103: case 103:
yyDollar = yyS[yypt-0 : yypt+1] yyDollar = yyS[yypt-0 : yypt+1]
//line promql/generated_parser.y:580 //line generated_parser.y:580
{ {
yyVAL.series = []SequenceValue{} yyVAL.series = []SequenceValue{}
} }
case 104: case 104:
yyDollar = yyS[yypt-3 : yypt+1] 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...) yyVAL.series = append(yyDollar[1].series, yyDollar[3].series...)
} }
case 105: case 105:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:584 //line generated_parser.y:584
{ {
yyVAL.series = yyDollar[1].series yyVAL.series = yyDollar[1].series
} }
case 106: case 106:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:586 //line generated_parser.y:586
{ {
yylex.(*parser).unexpected("series values", "") yylex.(*parser).unexpected("series values", "")
yyVAL.series = nil yyVAL.series = nil
} }
case 107: case 107:
yyDollar = yyS[yypt-1 : yypt+1] 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: case 108:
yyDollar = yyS[yypt-3 : yypt+1] yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:592 //line generated_parser.y:592
{ {
yyVAL.series = []SequenceValue{} yyVAL.series = []SequenceValue{}
for i := uint64(0); i < yyDollar[3].uint; i++ { 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: case 109:
yyDollar = yyS[yypt-1 : yypt+1] 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: case 110:
yyDollar = yyS[yypt-3 : yypt+1] yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:601 //line generated_parser.y:601
{ {
yyVAL.series = []SequenceValue{} yyVAL.series = []SequenceValue{}
for i := uint64(0); i <= yyDollar[3].uint; i++ { 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: case 111:
yyDollar = yyS[yypt-4 : yypt+1] yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:608 //line generated_parser.y:608
{ {
yyVAL.series = []SequenceValue{} yyVAL.series = []SequenceValue{}
for i := uint64(0); i <= yyDollar[4].uint; i++ { 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 yyDollar[1].float += yyDollar[2].float
} }
} }
case 112: case 112:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:618 //line generated_parser.y:618
{ {
if yyDollar[1].item.Val != "stale" { if yyDollar[1].item.Val != "stale" {
yylex.(*parser).unexpected("series values", "number or \"stale\"") yylex.(*parser).unexpected("series values", "number or \"stale\"")
@ -1474,7 +1474,7 @@ yydefault:
} }
case 155: case 155:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:649 //line generated_parser.y:649
{ {
yyVAL.node = &NumberLiteral{ yyVAL.node = &NumberLiteral{
Val: yylex.(*parser).number(yyDollar[1].item.Val), Val: yylex.(*parser).number(yyDollar[1].item.Val),
@ -1483,25 +1483,25 @@ yydefault:
} }
case 156: case 156:
yyDollar = yyS[yypt-1 : yypt+1] 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) yyVAL.float = yylex.(*parser).number(yyDollar[1].item.Val)
} }
case 157: case 157:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:659 //line generated_parser.y:659
{ {
yyVAL.float = yyDollar[2].float yyVAL.float = yyDollar[2].float
} }
case 158: case 158:
yyDollar = yyS[yypt-2 : yypt+1] yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:660 //line generated_parser.y:660
{ {
yyVAL.float = -yyDollar[2].float yyVAL.float = -yyDollar[2].float
} }
case 159: case 159:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:664 //line generated_parser.y:664
{ {
var err error var err error
yyVAL.uint, err = strconv.ParseUint(yyDollar[1].item.Val, 10, 64) yyVAL.uint, err = strconv.ParseUint(yyDollar[1].item.Val, 10, 64)
@ -1511,7 +1511,7 @@ yydefault:
} }
case 160: case 160:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:674 //line generated_parser.y:674
{ {
var err error var err error
yyVAL.duration, err = parseDuration(yyDollar[1].item.Val) yyVAL.duration, err = parseDuration(yyDollar[1].item.Val)
@ -1521,7 +1521,7 @@ yydefault:
} }
case 161: case 161:
yyDollar = yyS[yypt-1 : yypt+1] yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:685 //line generated_parser.y:685
{ {
yyVAL.node = &StringLiteral{ yyVAL.node = &StringLiteral{
Val: yylex.(*parser).unquoteString(yyDollar[1].item.Val), Val: yylex.(*parser).unquoteString(yyDollar[1].item.Val),
@ -1530,13 +1530,13 @@ yydefault:
} }
case 162: case 162:
yyDollar = yyS[yypt-0 : yypt+1] yyDollar = yyS[yypt-0 : yypt+1]
//line promql/generated_parser.y:698 //line generated_parser.y:698
{ {
yyVAL.duration = 0 yyVAL.duration = 0
} }
case 164: case 164:
yyDollar = yyS[yypt-0 : yypt+1] yyDollar = yyS[yypt-0 : yypt+1]
//line promql/generated_parser.y:702 //line generated_parser.y:702
{ {
yyVAL.strings = nil yyVAL.strings = nil
} }

20
promql/parser/lex.go
View file

@ -36,11 +36,11 @@ func (i Item) String() string {
return i.Val return i.Val
case i.Typ == IDENTIFIER || i.Typ == METRIC_IDENTIFIER: case i.Typ == IDENTIFIER || i.Typ == METRIC_IDENTIFIER:
return fmt.Sprintf("%q", i.Val) return fmt.Sprintf("%q", i.Val)
case i.Typ.isKeyword(): case i.Typ.IsKeyword():
return fmt.Sprintf("<%s>", i.Val) return fmt.Sprintf("<%s>", i.Val)
case i.Typ.isOperator(): case i.Typ.IsOperator():
return fmt.Sprintf("<op:%s>", i.Val) return fmt.Sprintf("<op:%s>", i.Val)
case i.Typ.isAggregator(): case i.Typ.IsAggregator():
return fmt.Sprintf("<aggr:%s>", i.Val) return fmt.Sprintf("<aggr:%s>", i.Val)
case len(i.Val) > 10: case len(i.Val) > 10:
return fmt.Sprintf("%.10q...", i.Val) 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. // isOperator returns true if the Item corresponds to a arithmetic or set operator.
// Returns false otherwise. // 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. // isAggregator returns true if the Item belongs to the aggregator functions.
// Returns false otherwise // 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. // isAggregator returns true if the Item is an aggregator that takes a parameter.
// Returns false otherwise // Returns false otherwise
func (i ItemType) isAggregatorWithParam() bool { func (i ItemType) IsAggregatorWithParam() bool {
return i == TOPK || i == BOTTOMK || i == COUNT_VALUES || i == QUANTILE return i == TOPK || i == BOTTOMK || i == COUNT_VALUES || i == QUANTILE
} }
// isKeyword returns true if the Item corresponds to a keyword. // isKeyword returns true if the Item corresponds to a keyword.
// Returns false otherwise. // 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. // Returns false otherwise.
func (i ItemType) isComparisonOperator() bool { func (i ItemType) IsComparisonOperator() bool {
switch i { switch i {
case EQL, NEQ, LTE, LSS, GTE, GTR: case EQL, NEQ, LTE, LSS, GTE, GTR:
return true return true
@ -78,7 +78,7 @@ func (i ItemType) isComparisonOperator() bool {
} }
// isSetOperator returns whether the Item corresponds to a set operator. // isSetOperator returns whether the Item corresponds to a set operator.
func (i ItemType) isSetOperator() bool { func (i ItemType) IsSetOperator() bool {
switch i { switch i {
case LAND, LOR, LUNLESS: case LAND, LOR, LUNLESS:
return true return true

34
promql/parser/parse.go
View file

@ -57,14 +57,14 @@ type ParseErr struct {
Err error Err error
Query string Query string
// An additional line offset to be added. Only used inside unit tests. // LineOffset is an additional line offset to be added. Only used inside unit tests.
lineOffset int LineOffset int
} }
func (e *ParseErr) Error() string { func (e *ParseErr) Error() string {
pos := int(e.PositionRange.Start) pos := int(e.PositionRange.Start)
lastLineBreak := -1 lastLineBreak := -1
line := e.lineOffset + 1 line := e.LineOffset + 1
var positionStr string var positionStr string
@ -180,15 +180,15 @@ func newParser(input string) *parser {
// SequenceValue is an omittable value in a sequence of time series values. // SequenceValue is an omittable value in a sequence of time series values.
type SequenceValue struct { type SequenceValue struct {
value float64 Value float64
omitted bool Omitted bool
} }
func (v SequenceValue) String() string { func (v SequenceValue) String() string {
if v.omitted { if v.Omitted {
return "_" return "_"
} }
return fmt.Sprintf("%f", v.value) return fmt.Sprintf("%f", v.Value)
} }
type seriesDescription struct { type seriesDescription struct {
@ -196,8 +196,8 @@ type seriesDescription struct {
values []SequenceValue values []SequenceValue
} }
// parseSeriesDesc parses the description of a time series. // ParseSeriesDesc parses the description of a time series.
func parseSeriesDesc(input string) (labels labels.Labels, values []SequenceValue, err error) { func ParseSeriesDesc(input string) (labels labels.Labels, values []SequenceValue, err error) {
p := newParser(input) p := newParser(input)
p.lex.seriesDesc = true p.lex.seriesDesc = true
@ -382,7 +382,7 @@ func (p *parser) newAggregateExpr(op Item, modifier Node, args Node) (ret *Aggre
} }
desiredArgs := 1 desiredArgs := 1
if ret.Op.isAggregatorWithParam() { if ret.Op.IsAggregatorWithParam() {
desiredArgs = 2 desiredArgs = 2
ret.Param = arguments[0] ret.Param = arguments[0]
@ -450,7 +450,7 @@ func (p *parser) checkAST(node Node) (typ ValueType) {
} }
} }
case *AggregateExpr: 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.addParseErrf(n.PositionRange(), "aggregation operator expected in aggregation expression but got %q", n.Op)
} }
p.expectType(n.Expr, ValueTypeVector, "aggregation expression") p.expectType(n.Expr, ValueTypeVector, "aggregation expression")
@ -476,15 +476,15 @@ func (p *parser) checkAST(node Node) (typ ValueType) {
return 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") 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") 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 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) p.addParseErrf(n.PositionRange(), "binary expression does not support operator %q", n.Op)
} }
if lt != ValueTypeScalar && lt != ValueTypeVector { if lt != ValueTypeScalar && lt != ValueTypeVector {
@ -513,7 +513,7 @@ func (p *parser) checkAST(node Node) (typ ValueType) {
n.VectorMatching = nil n.VectorMatching = nil
} else { } else {
// Both operands are Vectors. // Both operands are Vectors.
if n.Op.isSetOperator() { if n.Op.IsSetOperator() {
if n.VectorMatching.Card == CardOneToMany || n.VectorMatching.Card == CardManyToOne { if n.VectorMatching.Card == CardOneToMany || n.VectorMatching.Card == CardManyToOne {
p.addParseErrf(n.PositionRange(), "no grouping allowed for %q operation", n.Op) 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) p.addParseErrf(n.PositionRange(), "set operator %q not allowed in binary scalar expression", n.Op)
} }

2
promql/parser/parse_test.go
View file

@ -2615,7 +2615,7 @@ func newSeq(vals ...float64) (res []SequenceValue) {
func TestParseSeries(t *testing.T) { func TestParseSeries(t *testing.T) {
for _, test := range testSeries { for _, test := range testSeries {
metric, vals, err := parseSeriesDesc(test.input) metric, vals, err := ParseSeriesDesc(test.input)
// Unexpected errors are always caused by a bug. // Unexpected errors are always caused by a bug.
testutil.Assert(t, err != errUnexpected, "unexpected error occurred") testutil.Assert(t, err != errUnexpected, "unexpected error occurred")

2
promql/parser/printer.go
View file

@ -72,7 +72,7 @@ func (node *AggregateExpr) String() string {
} }
aggrString += "(" aggrString += "("
if node.Op.isAggregatorWithParam() { if node.Op.IsAggregatorWithParam() {
aggrString += fmt.Sprintf("%s, ", node.Param) aggrString += fmt.Sprintf("%s, ", node.Param)
} }
aggrString += fmt.Sprintf("%s)", node.Expr) aggrString += fmt.Sprintf("%s)", node.Expr)

42
promql/test.go
View file

@ -103,7 +103,7 @@ func (t *Test) Storage() storage.Storage {
func raise(line int, format string, v ...interface{}) error { func raise(line int, format string, v ...interface{}) error {
return &parser.ParseErr{ return &parser.ParseErr{
lineOffset: line, LineOffset: line,
Err: errors.Errorf(format, v...), Err: errors.Errorf(format, v...),
} }
} }
@ -114,7 +114,7 @@ func parseLoad(lines []string, i int) (int, *loadCmd, error) {
} }
parts := patLoad.FindStringSubmatch(lines[i]) parts := patLoad.FindStringSubmatch(lines[i])
gap, err := model.parser.ParseDuration(parts[1]) gap, err := model.ParseDuration(parts[1])
if err != nil { if err != nil {
return i, nil, raise(i, "invalid step definition %q: %s", parts[1], err) 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-- i--
break break
} }
metric, vals, err := parseSeriesDesc(defLine) metric, vals, err := parser.ParseSeriesDesc(defLine)
if err != nil { if err != nil {
if perr, ok := err.(*parser.ParseErr); ok { if perr, ok := err.(*parser.ParseErr); ok {
perr.lineOffset = i perr.LineOffset = i
} }
return i, nil, err return i, nil, err
} }
@ -151,8 +151,8 @@ func (t *Test) parseEval(lines []string, i int) (int, *evalCmd, error) {
_, err := parser.ParseExpr(expr) _, err := parser.ParseExpr(expr)
if err != nil { if err != nil {
if perr, ok := err.(*parser.ParseErr); ok { if perr, ok := err.(*parser.ParseErr); ok {
perr.lineOffset = i perr.LineOffset = i
posOffset := Pos(strings.Index(lines[i], expr)) posOffset := parser.Pos(strings.Index(lines[i], expr))
perr.PositionRange.Start += posOffset perr.PositionRange.Start += posOffset
perr.PositionRange.End += posOffset perr.PositionRange.End += posOffset
perr.Query = lines[i] perr.Query = lines[i]
@ -160,7 +160,7 @@ func (t *Test) parseEval(lines []string, i int) (int, *evalCmd, error) {
return i, nil, err return i, nil, err
} }
offset, err := model.parser.ParseDuration(at) offset, err := model.ParseDuration(at)
if err != nil { if err != nil {
return i, nil, raise(i, "invalid step definition %q: %s", parts[1], err) 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 break
} }
if f, err := parseNumber(defLine); err == nil { if f, err := parseNumber(defLine); err == nil {
cmd.expect(0, nil, parser.SequenceValue{value: f}) cmd.expect(0, nil, parser.SequenceValue{Value: f})
break break
} }
metric, vals, err := parseSeriesDesc(defLine) metric, vals, err := parser.ParseSeriesDesc(defLine)
if err != nil { if err != nil {
if perr, ok := err.(*parser.ParseErr); ok { if perr, ok := err.(*parser.ParseErr); ok {
perr.lineOffset = i perr.LineOffset = i
} }
return i, nil, err return i, nil, err
} }
@ -282,10 +282,10 @@ func (cmd *loadCmd) set(m labels.Labels, vals ...parser.SequenceValue) {
samples := make([]Point, 0, len(vals)) samples := make([]Point, 0, len(vals))
ts := testStartTime ts := testStartTime
for _, v := range vals { for _, v := range vals {
if !v.omitted { if !v.Omitted {
samples = append(samples, Point{ samples = append(samples, Point{
T: ts.UnixNano() / int64(time.Millisecond/time.Nanosecond), T: ts.UnixNano() / int64(time.Millisecond/time.Nanosecond),
V: v.value, V: v.Value,
}) })
} }
ts = ts.Add(cmd.gap) ts = ts.Add(cmd.gap)
@ -374,8 +374,8 @@ func (ev *evalCmd) compareResult(result parser.Value) error {
if ev.ordered && exp.pos != pos+1 { 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) 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) { 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) return errors.Errorf("expected %v for %s but got %v", exp.vals[0].Value, v.Metric, v.V)
} }
seen[fp] = true seen[fp] = true
@ -391,8 +391,8 @@ func (ev *evalCmd) compareResult(result parser.Value) error {
} }
case Scalar: case Scalar:
if !almostEqual(ev.expected[0].vals[0].value, val.V) { 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) return errors.Errorf("expected Scalar %v but got %v", val.V, ev.expected[0].vals[0].Value)
} }
default: 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) 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 { if err != nil {
return errors.Wrapf(err, "error in %s %s", cmd, cmd.expr) 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. // Ordering isn't defined for range queries.
return nil return nil
} }
mat := rangeRes.parser.Value.(Matrix) mat := rangeRes.Value.(Matrix)
vec := make(Vector, 0, len(mat)) vec := make(Vector, 0, len(mat))
for _, series := range mat { for _, series := range mat {
for _, point := range series.Points { 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}) err = cmd.compareResult(Scalar{V: vec[0].Point.V})
} else { } else {
err = cmd.compareResult(vec) err = cmd.compareResult(vec)
@ -559,10 +559,10 @@ func almostEqual(a, b float64) bool {
} }
func parseNumber(s string) (float64, error) { func parseNumber(s string) (float64, error) {
n, err := strconv.parser.ParseInt(s, 0, 64) n, err := strconv.ParseInt(s, 0, 64)
f := float64(n) f := float64(n)
if err != nil { if err != nil {
f, err = strconv.parser.ParseFloat(s, 64) f, err = strconv.ParseFloat(s, 64)
} }
if err != nil { if err != nil {
return 0, errors.Wrap(err, "error parsing number") return 0, errors.Wrap(err, "error parsing number")